Changeset 9725


Ignore:
Timestamp:
09/09/11 08:35:15 (14 years ago)
Author:
Mathieu Morlighem
Message:

Some more objects in mesh

Location:
issm/trunk
Files:
8 added
9 deleted
238 edited
1 moved

Legend:

Unmodified
Added
Removed

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

    r9719 r9725  
    149149        MeshAverageVertexConnectivityEnum,
    150150        MeshDimensionEnum,
     151        MeshNumberofelementsEnum,
     152        MeshNumberofverticesEnum,
     153        MeshNumberofelements2dEnum,
     154        MeshNumberofedgesEnum,
     155        MeshNumberoflayersEnum,
     156        MeshNumberofvertices2dEnum,
    151157        /*}}}*/
    152158        /*Datasets {{{1*/
    … …  
    184190        //transient
    185191        TransientSolutionEnum,
    186         GroundinglineMigration2DSolutionEnum,
     192        GroundinglineMigration2dSolutionEnum,
    187193        //slope
    188194        BedSlopeSolutionEnum,
    … …  
    412418        OldGradientEnum,
    413419        ControlSteadyEnum,
    414         NumberOfElementsEnum,
    415         NumberOfVerticesEnum,
     420
    416421        OutputFilePointerEnum,
    417422        QmuErrNameEnum,
    … …  
    463468        TransientInputEnum,
    464469        /*Temporary*/
    465         NumberOfElements2DEnum,
    466470        YEnum,
    467         NumberOfNodes2DEnum,
    468471        ZEnum,
    469472        UpperelementsEnum,
    470473        EdgesEnum,
    471         Elements2DEnum,
     474        Elements2dEnum,
    472475        XEnum,
    473476        ElementconnectivityEnum,
    474         NumlayersEnum,
    475477        LowerelementsEnum,
    476478        OutputfilenameEnum,
    477479        WaterfractionEnum,
    478480        WatercolumnEnum,
    479         NumberOfResponsesEnum,
    480481        BasalFrictionEnum,
    481482        ViscousHeatingEnum,
    … …  
    484485        HydrologyWaterVyEnum,
    485486        SpcDynamicEnum,
    486         NumberOfEdgesEnum,
    487487        MaximumNumberOfEnums
    488488};

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

    r8263 r9725  
    2222
    2323        /*Recover numberofelements: */
    24         parameters->FindParam(&numberofelements,NumberOfElementsEnum);
     24        parameters->FindParam(&numberofelements,MeshNumberofelementsEnum);
    2525
    2626        /*Allocate sigma on numberofelements: */

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

    r4637 r9725  
    2222
    2323        /*Recover numberofelements: */
    24         parameters->FindParam(&numberofelements,NumberOfElementsEnum);
     24        parameters->FindParam(&numberofelements,MeshNumberofelementsEnum);
    2525
    2626        /*Allocate eps on numberofelements (only 1 dof): */

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

    r9719 r9725  
    153153                case MeshAverageVertexConnectivityEnum : return "MeshAverageVertexConnectivity";
    154154                case MeshDimensionEnum : return "MeshDimension";
     155                case MeshNumberofelementsEnum : return "MeshNumberofelements";
     156                case MeshNumberofverticesEnum : return "MeshNumberofvertices";
     157                case MeshNumberofelements2dEnum : return "MeshNumberofelements2d";
     158                case MeshNumberofedgesEnum : return "MeshNumberofedges";
     159                case MeshNumberoflayersEnum : return "MeshNumberoflayers";
     160                case MeshNumberofvertices2dEnum : return "MeshNumberofvertices2d";
    155161                case ConstraintsEnum : return "Constraints";
    156162                case ElementsEnum : return "Elements";
    … …  
    177183                case HydrologyAnalysisEnum : return "HydrologyAnalysis";
    178184                case TransientSolutionEnum : return "TransientSolution";
    179                 case GroundinglineMigration2DSolutionEnum : return "GroundinglineMigration2DSolution";
     185                case GroundinglineMigration2dSolutionEnum : return "GroundinglineMigration2dSolution";
    180186                case BedSlopeSolutionEnum : return "BedSlopeSolution";
    181187                case BedSlopeAnalysisEnum : return "BedSlopeAnalysis";
    … …  
    364370                case OldGradientEnum : return "OldGradient";
    365371                case ControlSteadyEnum : return "ControlSteady";
    366                 case NumberOfElementsEnum : return "NumberOfElements";
    367                 case NumberOfVerticesEnum : return "NumberOfVertices";
    368372                case OutputFilePointerEnum : return "OutputFilePointer";
    369373                case QmuErrNameEnum : return "QmuErrName";
    … …  
    407411                case DragCoefficientAbsGradientEnum : return "DragCoefficientAbsGradient";
    408412                case TransientInputEnum : return "TransientInput";
    409                 case NumberOfElements2DEnum : return "NumberOfElements2D";
    410413                case YEnum : return "Y";
    411                 case NumberOfNodes2DEnum : return "NumberOfNodes2D";
    412414                case ZEnum : return "Z";
    413415                case UpperelementsEnum : return "Upperelements";
    414416                case EdgesEnum : return "Edges";
    415                 case Elements2DEnum : return "Elements2D";
     417                case Elements2dEnum : return "Elements2d";
    416418                case XEnum : return "X";
    417419                case ElementconnectivityEnum : return "Elementconnectivity";
    418                 case NumlayersEnum : return "Numlayers";
    419420                case LowerelementsEnum : return "Lowerelements";
    420421                case OutputfilenameEnum : return "Outputfilename";
    421422                case WaterfractionEnum : return "Waterfraction";
    422423                case WatercolumnEnum : return "Watercolumn";
    423                 case NumberOfResponsesEnum : return "NumberOfResponses";
    424424                case BasalFrictionEnum : return "BasalFriction";
    425425                case ViscousHeatingEnum : return "ViscousHeating";
    … …  
    428428                case HydrologyWaterVyEnum : return "HydrologyWaterVy";
    429429                case SpcDynamicEnum : return "SpcDynamic";
    430                 case NumberOfEdgesEnum : return "NumberOfEdges";
    431430                default : return "unknown";
    432431

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

    r9405 r9725  
    3333
    3434        /*Fetch parameters: */
    35         iomodel->Constant(&numberofvertices,NumberOfVerticesEnum);
     35        iomodel->Constant(&numberofvertices,MeshNumberofverticesEnum);
    3636
    3737        /*First of, find the record for the enum, and get code  of data type: */

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

    r9646 r9725  
    2121        /*Fetch parameters: */
    2222        iomodel->Constant(&stabilization,BalancethicknessStabilizationEnum);
    23         iomodel->Constant(&numberofedges,NumberOfEdgesEnum);
     23        iomodel->Constant(&numberofedges,MeshNumberofedgesEnum);
    2424
    2525        /*Output*/

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

    r9719 r9725  
    3131        /*Fetch parameters: */
    3232        iomodel->Constant(&dim,MeshDimensionEnum);
    33         iomodel->Constant(&numberofelements,NumberOfElementsEnum);
    34         iomodel->Constant(&numberofvertices,NumberOfVerticesEnum);
     33        iomodel->Constant(&numberofelements,MeshNumberofelementsEnum);
     34        iomodel->Constant(&numberofvertices,MeshNumberofverticesEnum);
    3535        iomodel->Constant(&stabilization,BalancethicknessStabilizationEnum);
    3636

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

    r9719 r9725  
    2121        /*Fetch data needed: */
    2222        iomodel->Constant(&dim,MeshDimensionEnum);
    23         iomodel->Constant(&numberofelements,NumberOfElementsEnum);
     23        iomodel->Constant(&numberofelements,MeshNumberofelementsEnum);
    2424        iomodel->FetchData(1,ElementsEnum);
    2525

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

    r9661 r9725  
    2424
    2525        /*Fetch parameters: */
    26         iomodel->Constant(&numberofvertices,NumberOfVerticesEnum);
     26        iomodel->Constant(&numberofvertices,MeshNumberofverticesEnum);
    2727
    2828        /*Recover pointer: */

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

    r9719 r9725  
    2121        /*Fetch data needed: */
    2222        iomodel->Constant(&dim,MeshDimensionEnum);
    23         iomodel->Constant(&numberofelements,NumberOfElementsEnum);
     23        iomodel->Constant(&numberofelements,MeshNumberofelementsEnum);
    2424        iomodel->FetchData(1,ElementsEnum);
    2525

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

    r9681 r9725  
    2727       
    2828        /*Fetch parameters: */
    29         iomodel->Constant(&numberofelements,NumberOfElementsEnum);
     29        iomodel->Constant(&numberofelements,MeshNumberofelementsEnum);
    3030        iomodel->Constant(&control_analysis,InversionIscontrolEnum);
    3131        iomodel->Constant(&num_control_type,InversionNumControlParametersEnum);

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

    r9719 r9725  
    2929        /*Fetch parameters: */
    3030        iomodel->Constant(&dim,MeshDimensionEnum);
    31         iomodel->Constant(&numberofelements,NumberOfElementsEnum);
    32         iomodel->Constant(&numberofvertices,NumberOfVerticesEnum);
     31        iomodel->Constant(&numberofelements,MeshNumberofelementsEnum);
     32        iomodel->Constant(&numberofvertices,MeshNumberofverticesEnum);
    3333        iomodel->Constant(&control_analysis,InversionIscontrolEnum);
    3434

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

    r9719 r9725  
    3030        /*Fetch parameters: */
    3131        iomodel->Constant(&dim,MeshDimensionEnum);
    32         iomodel->Constant(&numberofelements,NumberOfElementsEnum);
    33         iomodel->Constant(&numberofvertices,NumberOfVerticesEnum);
     32        iomodel->Constant(&numberofelements,MeshNumberofelementsEnum);
     33        iomodel->Constant(&numberofvertices,MeshNumberofverticesEnum);
    3434        elements=iomodel->Data(ElementsEnum);
    3535

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

    r9721 r9725  
    6060        parameters->AddObject(iomodel->CopyConstantObject(DiagnosticViscosityOvershootEnum));
    6161        parameters->AddObject(iomodel->CopyConstantObject(SettingsWaitonlockEnum));
    62         parameters->AddObject(iomodel->CopyConstantObject(NumberOfElementsEnum));
     62        parameters->AddObject(iomodel->CopyConstantObject(MeshNumberofelementsEnum));
    6363        parameters->AddObject(iomodel->CopyConstantObject(SettingsIoGatherEnum));
    6464        parameters->AddObject(iomodel->CopyConstantObject(GroundinglineMigrationEnum));

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

    r9719 r9725  
    3333        /*Fetch parameters: */
    3434        iomodel->Constant(&dim,MeshDimensionEnum);
    35         iomodel->Constant(&numberofelements,NumberOfElementsEnum);
    36         iomodel->Constant(&numberofvertices,NumberOfVerticesEnum);
     35        iomodel->Constant(&numberofelements,MeshNumberofelementsEnum);
     36        iomodel->Constant(&numberofvertices,MeshNumberofverticesEnum);
    3737        elements=iomodel->Data(ElementsEnum);
    3838

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

    r9719 r9725  
    4141        iomodel->Constant(&dim,MeshDimensionEnum);
    4242        iomodel->Constant(&yts,ConstantsYtsEnum);
    43         iomodel->Constant(&numberofvertices,NumberOfVerticesEnum);
     43        iomodel->Constant(&numberofvertices,MeshNumberofverticesEnum);
    4444        iomodel->Constant(&g,ConstantsGEnum);
    4545        iomodel->Constant(&rho_ice,MaterialsRhoIceEnum);

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

    r9719 r9725  
    4141        /*Fetch parameters: */
    4242        iomodel->Constant(&dim,MeshDimensionEnum);
    43         iomodel->Constant(&numberofvertices,NumberOfVerticesEnum);
     43        iomodel->Constant(&numberofvertices,MeshNumberofverticesEnum);
    4444        iomodel->Constant(&isstokes,FlowequationIsstokesEnum);
    4545        iomodel->Constant(&ismacayealpattyn,FlowequationIsmacayealpattynEnum);

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

    r9679 r9725  
    2525
    2626        /*Fetch parameters: */
    27         iomodel->Constant(&numberofvertices,NumberOfVerticesEnum);
     27        iomodel->Constant(&numberofvertices,MeshNumberofverticesEnum);
    2828        iomodel->Constant(&isstokes,FlowequationIsstokesEnum);
    2929        iomodel->Constant(&ismacayealpattyn,FlowequationIsmacayealpattynEnum);

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

    r9719 r9725  
    2727        iomodel->Constant(&ismacayealpattyn,FlowequationIsmacayealpattynEnum);
    2828        iomodel->Constant(&dim,MeshDimensionEnum);
    29         iomodel->Constant(&numberofelements,NumberOfElementsEnum);
     29        iomodel->Constant(&numberofelements,MeshNumberofelementsEnum);
    3030        iomodel->Constant(&control_analysis,InversionIscontrolEnum);
    3131        iomodel->Constant(&dakota_analysis,QmuIsdakotaEnum);

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

    r9679 r9725  
    2929        /*Fetch parameters: */
    3030        iomodel->Constant(&yts,ConstantsYtsEnum);
    31         iomodel->Constant(&numberofvertices,NumberOfVerticesEnum);
     31        iomodel->Constant(&numberofvertices,MeshNumberofverticesEnum);
    3232        iomodel->Constant(&ishutter,FlowequationIshutterEnum);
    3333

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

    r9661 r9725  
    2525
    2626        /*Fetch parameters: */
    27         iomodel->Constant(&numberofvertices,NumberOfVerticesEnum);
     27        iomodel->Constant(&numberofvertices,MeshNumberofverticesEnum);
    2828        iomodel->Constant(&ishutter,FlowequationIshutterEnum);
    2929

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

    r9691 r9725  
    2121       
    2222        /*Fetch data needed: */
    23         iomodel->Constant(&numberofelements,NumberOfElementsEnum);
     23        iomodel->Constant(&numberofelements,MeshNumberofelementsEnum);
    2424        iomodel->Constant(&ishutter,FlowequationIshutterEnum);
    2525

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

    r9719 r9725  
    2626        iomodel->Constant(&dim,MeshDimensionEnum);
    2727        iomodel->Constant(&yts,ConstantsYtsEnum);
    28         iomodel->Constant(&numberofvertices,NumberOfVerticesEnum);
     28        iomodel->Constant(&numberofvertices,MeshNumberofverticesEnum);
    2929
    3030        /*Recover pointer: */

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

    r9719 r9725  
    2626        /*Fetch parameters: */
    2727        iomodel->Constant(&dim,MeshDimensionEnum);
    28         iomodel->Constant(&numberofvertices,NumberOfVerticesEnum);
     28        iomodel->Constant(&numberofvertices,MeshNumberofverticesEnum);
    2929
    3030        /*Recover pointer: */

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

    r9719 r9725  
    2121        /*Fetch parameters: */
    2222        iomodel->Constant(&dim,MeshDimensionEnum);
    23         iomodel->Constant(&numberofelements,NumberOfElementsEnum);
     23        iomodel->Constant(&numberofelements,MeshNumberofelementsEnum);
    2424
    2525        /*Now, is the model 3d? otherwise, do nothing: */

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

    r9719 r9725  
    4949        /*Fetch parameters: */
    5050        iomodel->Constant(&dim,MeshDimensionEnum);
    51         iomodel->Constant(&numberofelements,NumberOfElementsEnum);
    52         iomodel->Constant(&numberofvertices,NumberOfVerticesEnum);
    53         iomodel->Constant(&numberofelements2d,NumberOfElements2DEnum);
    54         iomodel->Constant(&numberofvertices2d,NumberOfNodes2DEnum);
    55         iomodel->Constant(&numlayers,NumlayersEnum);
     51        iomodel->Constant(&numberofelements,MeshNumberofelementsEnum);
     52        iomodel->Constant(&numberofvertices,MeshNumberofverticesEnum);
     53        iomodel->Constant(&numberofelements2d,MeshNumberofelements2dEnum);
     54        iomodel->Constant(&numberofvertices2d,MeshNumberofvertices2dEnum);
     55        iomodel->Constant(&numlayers,MeshNumberoflayersEnum);
    5656        iomodel->Constant(&numrifts,RiftsNumriftsEnum);
    5757
    … …  
    7171        else{
    7272                /*load elements2d: */
    73                 iomodel->FetchData(&elements2d,NULL,NULL,Elements2DEnum);
     73                iomodel->FetchData(&elements2d,NULL,NULL,Elements2dEnum);
    7474        }
    7575

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

    r9719 r9725  
    2727        /*Fetch parameters: */
    2828        iomodel->Constant(&dim,MeshDimensionEnum);
    29         iomodel->Constant(&numberofvertices,NumberOfVerticesEnum);
     29        iomodel->Constant(&numberofvertices,MeshNumberofverticesEnum);
    3030        iomodel->Constant(&heatcapacity,MaterialsHeatcapacityEnum);
    3131        iomodel->Constant(&referencetemperature,ConstantsReferencetemperatureEnum);

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

    r9661 r9725  
    2424
    2525        /*Fetch parameters: */
    26         iomodel->Constant(&numberofvertices,NumberOfVerticesEnum);
     26        iomodel->Constant(&numberofvertices,MeshNumberofverticesEnum);
    2727       
    2828        /*Recover pointer: */

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

    r9719 r9725  
    2121        /*Fetch parameters: */
    2222        iomodel->Constant(&dim,MeshDimensionEnum);
    23         iomodel->Constant(&numberofelements,NumberOfElementsEnum);
     23        iomodel->Constant(&numberofelements,MeshNumberofelementsEnum);
    2424
    2525        /*Now, is the model 3d? otherwise, do nothing: */

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

    r9661 r9725  
    2424
    2525        /*Fetch parameters: */
    26         iomodel->Constant(&numberofvertices,NumberOfVerticesEnum);
     26        iomodel->Constant(&numberofvertices,MeshNumberofverticesEnum);
    2727       
    2828        /*Recover pointer: */

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

    r9661 r9725  
    1919       
    2020        /*Fetch data needed: */
    21         iomodel->Constant(&numberofelements,NumberOfElementsEnum);
     21        iomodel->Constant(&numberofelements,MeshNumberofelementsEnum);
    2222        iomodel->FetchData(1,ElementsEnum);
    2323

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

    r9719 r9725  
    2323        /*Fetch parameters: */
    2424        iomodel->Constant(&dim,MeshDimensionEnum);
    25         iomodel->Constant(&numberofvertices,NumberOfVerticesEnum);
     25        iomodel->Constant(&numberofvertices,MeshNumberofverticesEnum);
    2626
    2727        /*if 2d: Error*/

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

    r9661 r9725  
    2424       
    2525        /*Fetch parameters: */
    26         iomodel->Constant(&numberofvertices,NumberOfVerticesEnum);
     26        iomodel->Constant(&numberofvertices,MeshNumberofverticesEnum);
    2727
    2828        /*Recover pointer: */

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

    r9719 r9725  
    2121        /*Fetch parameters: */
    2222        iomodel->Constant(&dim,MeshDimensionEnum);
    23         iomodel->Constant(&numberofelements,NumberOfElementsEnum);
     23        iomodel->Constant(&numberofelements,MeshNumberofelementsEnum);
    2424
    2525        /*Now, is the model 3d? otherwise, do nothing: */

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

    r9719 r9725  
    4242
    4343        /*Fetch parameters: */
    44         iomodel->Constant(&numberofvertices,NumberOfVerticesEnum);
     44        iomodel->Constant(&numberofvertices,MeshNumberofverticesEnum);
    4545
    4646        my_nodes=(bool*)xmalloc(numberofvertices*sizeof(bool));
    … …  
    5757
    5858        /*Fetch parameters: */
    59         iomodel->Constant(&numberofelements,NumberOfElementsEnum);
     59        iomodel->Constant(&numberofelements,MeshNumberofelementsEnum);
    6060
    6161        /*each element has it own nodes (as many as vertices) + additional nodes from neighbouring elements for each edge. This yields to a very different partition for

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

    r9642 r9725  
    2828        /*Fetch parameters: */
    2929        iomodel->Constant(&stabilization,PrognosticStabilizationEnum);
    30         iomodel->Constant(&numberofelements,NumberOfElementsEnum);
    31         iomodel->Constant(&numberofedges,NumberOfEdgesEnum);
     30        iomodel->Constant(&numberofelements,MeshNumberofelementsEnum);
     31        iomodel->Constant(&numberofedges,MeshNumberofedgesEnum);
    3232
    3333        /*Recover pointer: */

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

    r9719 r9725  
    3131        /*Fetch parameters: */
    3232        iomodel->Constant(&dim,MeshDimensionEnum);
    33         iomodel->Constant(&numberofelements,NumberOfElementsEnum);
    34         iomodel->Constant(&numberofvertices,NumberOfVerticesEnum);
     33        iomodel->Constant(&numberofelements,MeshNumberofelementsEnum);
     34        iomodel->Constant(&numberofvertices,MeshNumberofverticesEnum);
    3535        iomodel->Constant(&stabilization,PrognosticStabilizationEnum);
    3636

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

    r9719 r9725  
    2222        /*Fetch data needed: */
    2323        iomodel->Constant(&dim,MeshDimensionEnum);
    24         iomodel->Constant(&numberofelements,NumberOfElementsEnum);
     24        iomodel->Constant(&numberofelements,MeshNumberofelementsEnum);
    2525        iomodel->Constant(&stabilization,PrognosticStabilizationEnum);
    2626        iomodel->FetchData(1,ElementsEnum);

  • issm/trunk/src/c/modules/ModelProcessorx/Qmu/CreateParametersQmu.cpp

    r9666 r9725  
    7070                iomodel->Constant(&name,MiscellaneousNameEnum);
    7171                iomodel->Constant(&numberofresponses,QmuNumberofresponsesEnum);
    72                 iomodel->Constant(&numberofvertices,NumberOfVerticesEnum);
     72                iomodel->Constant(&numberofvertices,MeshNumberofverticesEnum);
    7373
    7474                /*name of qmu input, error and output files:{{{1*/

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

    r9661 r9725  
    2424
    2525        /*Fetch parameters: */
    26         iomodel->Constant(&numberofvertices,NumberOfVerticesEnum);
     26        iomodel->Constant(&numberofvertices,MeshNumberofverticesEnum);
    2727
    2828        /*Recover pointer: */

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

    r9719 r9725  
    2121        /*Fetch data needed: */
    2222        iomodel->Constant(&dim,MeshDimensionEnum);
    23         iomodel->Constant(&numberofelements,NumberOfElementsEnum);
     23        iomodel->Constant(&numberofelements,MeshNumberofelementsEnum);
    2424        iomodel->FetchData(1,ElementsEnum);
    2525

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

    r9719 r9725  
    2727        /*Fetch parameters: */
    2828        iomodel->Constant(&dim,MeshDimensionEnum);
    29         iomodel->Constant(&numberofvertices,NumberOfVerticesEnum);
     29        iomodel->Constant(&numberofvertices,MeshNumberofverticesEnum);
    3030
    3131        /*Create loads if they do not exist yet*/

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

    r9661 r9725  
    2424
    2525        /*Fetch parameters: */
    26         iomodel->Constant(&numberofvertices,NumberOfVerticesEnum);
     26        iomodel->Constant(&numberofvertices,MeshNumberofverticesEnum);
    2727
    2828        /*Recover pointer: */

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

    r9719 r9725  
    2222        /*Fetch parameters: */
    2323        iomodel->Constant(&dim,MeshDimensionEnum);
    24         iomodel->Constant(&numberofelements,NumberOfElementsEnum);
     24        iomodel->Constant(&numberofelements,MeshNumberofelementsEnum);
    2525        iomodel->Constant(&dakota_analysis,QmuIsdakotaEnum);
    2626

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

    r9719 r9725  
    151151        else if (strcmp(name,"MeshAverageVertexConnectivity")==0) return MeshAverageVertexConnectivityEnum;
    152152        else if (strcmp(name,"MeshDimension")==0) return MeshDimensionEnum;
     153        else if (strcmp(name,"MeshNumberofelements")==0) return MeshNumberofelementsEnum;
     154        else if (strcmp(name,"MeshNumberofvertices")==0) return MeshNumberofverticesEnum;
     155        else if (strcmp(name,"MeshNumberofelements2d")==0) return MeshNumberofelements2dEnum;
     156        else if (strcmp(name,"MeshNumberofedges")==0) return MeshNumberofedgesEnum;
     157        else if (strcmp(name,"MeshNumberoflayers")==0) return MeshNumberoflayersEnum;
     158        else if (strcmp(name,"MeshNumberofvertices2d")==0) return MeshNumberofvertices2dEnum;
    153159        else if (strcmp(name,"Constraints")==0) return ConstraintsEnum;
    154160        else if (strcmp(name,"Elements")==0) return ElementsEnum;
    … …  
    175181        else if (strcmp(name,"HydrologyAnalysis")==0) return HydrologyAnalysisEnum;
    176182        else if (strcmp(name,"TransientSolution")==0) return TransientSolutionEnum;
    177         else if (strcmp(name,"GroundinglineMigration2DSolution")==0) return GroundinglineMigration2DSolutionEnum;
     183        else if (strcmp(name,"GroundinglineMigration2dSolution")==0) return GroundinglineMigration2dSolutionEnum;
    178184        else if (strcmp(name,"BedSlopeSolution")==0) return BedSlopeSolutionEnum;
    179185        else if (strcmp(name,"BedSlopeAnalysis")==0) return BedSlopeAnalysisEnum;
    … …  
    362368        else if (strcmp(name,"OldGradient")==0) return OldGradientEnum;
    363369        else if (strcmp(name,"ControlSteady")==0) return ControlSteadyEnum;
    364         else if (strcmp(name,"NumberOfElements")==0) return NumberOfElementsEnum;
    365         else if (strcmp(name,"NumberOfVertices")==0) return NumberOfVerticesEnum;
    366370        else if (strcmp(name,"OutputFilePointer")==0) return OutputFilePointerEnum;
    367371        else if (strcmp(name,"QmuErrName")==0) return QmuErrNameEnum;
    … …  
    405409        else if (strcmp(name,"DragCoefficientAbsGradient")==0) return DragCoefficientAbsGradientEnum;
    406410        else if (strcmp(name,"TransientInput")==0) return TransientInputEnum;
    407         else if (strcmp(name,"NumberOfElements2D")==0) return NumberOfElements2DEnum;
    408411        else if (strcmp(name,"Y")==0) return YEnum;
    409         else if (strcmp(name,"NumberOfNodes2D")==0) return NumberOfNodes2DEnum;
    410412        else if (strcmp(name,"Z")==0) return ZEnum;
    411413        else if (strcmp(name,"Upperelements")==0) return UpperelementsEnum;
    412414        else if (strcmp(name,"Edges")==0) return EdgesEnum;
    413         else if (strcmp(name,"Elements2D")==0) return Elements2DEnum;
     415        else if (strcmp(name,"Elements2d")==0) return Elements2dEnum;
    414416        else if (strcmp(name,"X")==0) return XEnum;
    415417        else if (strcmp(name,"Elementconnectivity")==0) return ElementconnectivityEnum;
    416         else if (strcmp(name,"Numlayers")==0) return NumlayersEnum;
    417418        else if (strcmp(name,"Lowerelements")==0) return LowerelementsEnum;
    418419        else if (strcmp(name,"Outputfilename")==0) return OutputfilenameEnum;
    419420        else if (strcmp(name,"Waterfraction")==0) return WaterfractionEnum;
    420421        else if (strcmp(name,"Watercolumn")==0) return WatercolumnEnum;
    421         else if (strcmp(name,"NumberOfResponses")==0) return NumberOfResponsesEnum;
    422422        else if (strcmp(name,"BasalFriction")==0) return BasalFrictionEnum;
    423423        else if (strcmp(name,"ViscousHeating")==0) return ViscousHeatingEnum;
    … …  
    426426        else if (strcmp(name,"HydrologyWaterVy")==0) return HydrologyWaterVyEnum;
    427427        else if (strcmp(name,"SpcDynamic")==0) return SpcDynamicEnum;
    428         else if (strcmp(name,"NumberOfEdges")==0) return NumberOfEdgesEnum;
    429428        else _error_("Enum %s not found",name);
    430429

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

    r9691 r9725  
    48444844
    48454845        /*Fetch parameters: */
    4846         iomodel->Constant(&numberofvertices,NumberOfVerticesEnum);
    4847         iomodel->Constant(&numberofelements,NumberOfElementsEnum);
     4846        iomodel->Constant(&numberofvertices,MeshNumberofverticesEnum);
     4847        iomodel->Constant(&numberofelements,MeshNumberofelementsEnum);
    48484848        iomodel->Constant(&yts,ConstantsYtsEnum);
    48494849

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

    r9405 r9725  
    5151       
    5252        /*retrieve parameters: */
    53         iomodel->Constant(&matpar_id,NumberOfElementsEnum); matpar_id++;
     53        iomodel->Constant(&matpar_id,MeshNumberofelementsEnum); matpar_id++;
    5454
    5555        this->numanalyses=in_numanalyses;

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

    r9722 r9725  
    38983898
    38993899        /*Fetch parameters: */
    3900         iomodel->Constant(&numberofvertices,NumberOfVerticesEnum);
    3901         iomodel->Constant(&numberofelements,NumberOfElementsEnum);
     3900        iomodel->Constant(&numberofvertices,MeshNumberofverticesEnum);
     3901        iomodel->Constant(&numberofelements,MeshNumberofelementsEnum);
    39023902        iomodel->Constant(&yts,ConstantsYtsEnum);
    39033903

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

    r9405 r9725  
    4949
    5050        /*retrieve parameters: */
    51         iomodel->Constant(&matpar_id,NumberOfElementsEnum); matpar_id++;
     51        iomodel->Constant(&matpar_id,MeshNumberofelementsEnum); matpar_id++;
    5252       
    5353        this->numanalyses=in_numanalyses;

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

    r9476 r9725  
    828828
    829829        /*Fetch parameters: */
    830         this->constants->FindParam(&numberofelements,NumberOfElementsEnum);
     830        this->constants->FindParam(&numberofelements,MeshNumberofelementsEnum);
    831831
    832832        /*First of, find the record for the enum, and get code  of data type: */

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

    r9719 r9725  
    5555        /*find parameters: */
    5656        iomodel->Constant(&dim,MeshDimensionEnum);
    57         iomodel->Constant(&numberofelements,NumberOfElementsEnum);
     57        iomodel->Constant(&numberofelements,MeshNumberofelementsEnum);
    5858
    5959        /*First, retrieve element index and element type: */

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

    r9642 r9725  
    5454
    5555        /*Fetch parameters: */
    56         iomodel->Constant(&numberofelements,NumberOfElementsEnum);
     56        iomodel->Constant(&numberofelements,MeshNumberofelementsEnum);
    5757
    5858        /* Get MatPar id */

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

    r9679 r9725  
    5353
    5454        /*Fetch parameters: */
    55         iomodel->Constant(&numberofvertices,NumberOfVerticesEnum);
    56         iomodel->Constant(&numberofelements,NumberOfElementsEnum);
     55        iomodel->Constant(&numberofvertices,MeshNumberofverticesEnum);
     56        iomodel->Constant(&numberofelements,MeshNumberofelementsEnum);
    5757
    5858        /*Some checks if debugging activated*/

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

    r9679 r9725  
    5656
    5757        /*Fetch parameters: */
    58         iomodel->Constant(&numberofelements,NumberOfElementsEnum);
     58        iomodel->Constant(&numberofelements,MeshNumberofelementsEnum);
    5959        iomodel->Constant(&penalty_lock,DiagnosticRiftPenaltyLockEnum);
    6060

  • issm/trunk/src/c/solutions/AnalysisConfiguration.cpp

    r9571 r9725  
    107107                        break;
    108108               
    109                 case GroundinglineMigration2DSolutionEnum:
     109                case GroundinglineMigration2dSolutionEnum:
    110110                        numanalyses=2;
    111111                        analyses=(int*)xmalloc(numanalyses*sizeof(int));

  • issm/trunk/src/c/solutions/CorePointerFromSolutionEnum.cpp

    r9681 r9725  
    6060                        solutioncore=&transient_core;
    6161                        break;
    62                 case GroundinglineMigration2DSolutionEnum:
     62                case GroundinglineMigration2dSolutionEnum:
    6363                        solutioncore=&groundinglinemigration2d_core;
    6464                        break;

  • issm/trunk/src/c/solutions/groundinglinemigration2d_core.cpp

    r9641 r9725  
    2727        GroundingLineMigrationx(femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters);
    2828
    29         if(solution_type==GroundinglineMigration2DSolutionEnum){
     29        if(solution_type==GroundinglineMigration2dSolutionEnum){
    3030                _printf_(VerboseSolution(),"%s\n","   saving results\n");
    3131                InputToResultx(femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters,MaskElementonfloatingiceEnum);

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

    r9719 r9725  
    1313                long       = modelfield('default',NaN,'marshall',false);
    1414                hemisphere = modelfield('default',NaN,'marshall',false);
    15                 segments             = modelfield('default',NaN,'marshall',false);
    16                 segmentmarkers       = modelfield('default',NaN,'marshall',false);
    17                 dimension            = modelfield('default',0,'marshall',true,'format','Integer');
     15                segments            = modelfield('default',NaN,'marshall',false);
     16                segmentmarkers      = modelfield('default',NaN,'marshall',false);
     17                dimension           = modelfield('default',0,'marshall',true,'format','Integer');
     18                numberofelements    = modelfield('default',0,'marshall',true,'format','Integer');
     19                numberofvertices    = modelfield('default',0,'marshall',true,'format','Integer');
     20                numberofedges       = modelfield('default',0,'marshall',true,'format','Integer');
     21                numberoflayers      = modelfield('default',0,'marshall',true,'format','Integer');
     22                numberofvertices2d    = modelfield('default',0,'marshall',true,'format','Integer');
     23                numberofelements2d = modelfield('default',0,'marshall',true,'format','Integer');
    1824        end
    1925        methods

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

    r9719 r9725  
    3939                 initialization   = modelfield('default',0,'marshall',true);
    4040                 geometry         = modelfield('default',0,'marshall',true);
     41                 autodiff         = modelfield('default',0,'marshall',true);
    4142                 mesh             = modelfield('default',0,'marshall',true);
    4243
    4344                 %FIXME: all other fields should belong to other classes
    44                  numberofelements    = modelfield('default',0,'marshall',true,'format','Integer');
    45                  numberofnodes       = modelfield('default',0,'marshall',true,'format','Integer');
    4645                 elements            = modelfield('default',NaN,'marshall',true,'format','DoubleMat','mattype',2);
    4746                 x                   = modelfield('default',NaN,'marshall',true,'format','DoubleMat','mattype',1);
    … …  
    5150                 elementconnectivity = modelfield('default',NaN,'marshall',true,'format','DoubleMat','mattype',3);
    5251                 edges               = modelfield('default',NaN,'marshall',true,'format','DoubleMat','mattype',3);
    53 
    54                  numberofelements2d = modelfield('default',0,'marshall',true,'format','Integer');
    55                  numberofnodes2d    = modelfield('default',0,'marshall',true,'format','Integer');
    5652                 elements2d         = modelfield('default',NaN,'marshall',true,'format','DoubleMat','mattype',3);
    5753                 x2d                = modelfield('default',NaN,'marshall',false);
    … …  
    6359                 lowernodes           = modelfield('default',NaN,'marshall',false);
    6460
    65                  numlayers         = modelfield('default',0,'marshall',true,'format','Integer');
    6661                 elementonbed      = modelfield('default',NaN,'marshall',true,'format','BooleanMat','mattype',2);
    6762                 elementonsurface  = modelfield('default',NaN,'marshall',true,'format','BooleanMat','mattype',2);
    … …  
    206201                         if isfield(structmd,'accumulation'), md.surfaceforcings.mass_balance=structmd.accumulation; end
    207202                         if isfield(structmd,'accumulation_rate'), md.surfaceforcings.mass_balance=structmd.accumulation_rate; end
    208                          if isfield(structmd,'numberofgrids'), md.numberofnodes=structmd.numberofgrids; end
    209                          if isfield(structmd,'numberofgrids2d'), md.numberofnodes2d=structmd.numberofgrids2d; end
     203                         if isfield(structmd,'numberofgrids'), md.mesh.numberofverticess=structmd.numberofgrids; end
     204                         if isfield(structmd,'numberofgrids2d'), md.mesh.numberofverticess2d=structmd.numberofgrids2d; end
    210205                         if isfield(structmd,'uppergrids'), md.uppernodes=structmd.uppergrids; end
    211206                         if isfield(structmd,'lowergrids'), md.lowernodes=structmd.lowergrids; end
    … …  
    313308                         if isfield(structmd,'hemisphere'), md.mesh.hemisphere=structmd.hemisphere; end
    314309                         if isfield(structmd,'lat'), md.mesh.lat=structmd.lat; end
    315                          if isfield(structmd,'lon'), md.mesh.lon=structmd.lon; end
     310                         if isfield(structmd,'long'), md.mesh.long=structmd.long; end
    316311                         if isfield(structmd,'segments'), md.mesh.segments=structmd.segments; end
    317312                         if isfield(structmd,'segmentmarkers'), md.mesh.segmentmarkers=structmd.segmentmarkers; end
    318                          if isfield(structmd,'dimension'), md.mesh.dimension=structmd.dimension; end
     313                         if isfield(structmd,'dim'), md.mesh.dimension=structmd.dim; end
     314                         if isfield(structmd,'numlayers'), md.mesh.numberoflayers=structmd.numlayers; end
     315                         if isfield(structmd,'numberofelements'), md.mesh.numberofelements=structmd.numberofelements; end
     316                         if isfield(structmd,'numberofvertices'), md.mesh.numberofvertices=structmd.numberofvertices; end
     317                         if isfield(structmd,'numberofedges'), md.mesh.numberofedges=structmd.numberofedges; end
     318                         if isfield(structmd,'numberofelements2d'), md.mesh.numberofelements2d=structmd.numberofelements2d; end
     319                         if isfield(structmd,'numberofnodes2d'), md.mesh.numberofvertices2d=structmd.numberofnodes2d; end
    319320
    320321                         %Field changes
    … …  
    327328                         end
    328329                         if isfield(structmd,'spcvelocity'),
    329                                  md.spcvx=NaN*ones(md.numberofnodes,1);
    330                                  md.spcvy=NaN*ones(md.numberofnodes,1);
    331                                  md.spcvz=NaN*ones(md.numberofnodes,1);
     330                                 md.spcvx=NaN*ones(md.mesh.numberofvertices,1);
     331                                 md.spcvy=NaN*ones(md.mesh.numberofvertices,1);
     332                                 md.spcvz=NaN*ones(md.mesh.numberofvertices,1);
    332333                                 pos=find(structmd.spcvelocity(:,1)); md.spcvx(pos)=structmd.spcvelocity(pos,4);
    333334                                 pos=find(structmd.spcvelocity(:,2)); md.spcvy(pos)=structmd.spcvelocity(pos,5);
    … …  
    386387                         %New fields
    387388                         if ~isfield(structmd,'upperelements');
    388                                  md.upperelements=transpose(1:md.numberofelements)+md.numberofelements2d;
    389                                  md.upperelements(end-md.numberofelements2d+1:end)=NaN;
     389                                 md.upperelements=transpose(1:md.mesh.numberofelements)+md.mesh.numberofelements2d;
     390                                 md.upperelements(end-md.mesh.numberofelements2d+1:end)=NaN;
    390391                         end
    391392                         if ~isfield(structmd,'lowerelements');
    392                                  md.lowerelements=transpose(1:md.numberofelements)-md.numberofelements2d;
    393                                  md.lowerelements(1:md.numberofelements2d)=NaN;
     393                                 md.lowerelements=transpose(1:md.mesh.numberofelements)-md.mesh.numberofelements2d;
     394                                 md.lowerelements(1:md.mesh.numberofelements2d)=NaN;
    394395                         end
    395396                         if ~isfield(structmd,'diagnostic_ref');
    396                                  md.diagnostic_ref=NaN*ones(md.numberofnodes2d,6);
     397                                 md.diagnostic_ref=NaN*ones(md.mesh.numberofvertices2d,6);
    397398                         end
    398399                 end% }}}
    … …  
    439440                         md.geometry         = geometry;
    440441                         md.verbose          = verbose('solution',true,'qmu',true,'control',true);
     442                         md.autodiff         = autodiff;
    441443                         md.mesh             = mesh;
    442444                 end

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

    r9714 r9725  
    7474
    7575if exist('data','var') && ~isempty(data)
    76     if     (numel(data)==md.numberofelements)
     76    if     (numel(data)==md.mesh.numberofelements)
    7777        edata=data;
    78     elseif (numel(data)==md.numberofnodes)
     78    elseif (numel(data)==md.mesh.numberofvertices)
    7979        ndata=data;
    8080        display('Averaging nodal data to element data.');
    81         edata=zeros(1,md.numberofelements);
     81        edata=zeros(1,md.mesh.numberofelements);
    8282        for i=1:size(md.elements,1)
    8383            for j=1:size(md.elements,2)
    … …  
    124124kfold.visibility=1;
    125125kfold.descript  =sprintf('Elements=%d, Nodes=%d',...
    126     md.numberofelements,md.numberofnodes);
     126    md.mesh.numberofelements,md.mesh.numberofvertices);
    127127% see matlab_oop, "initializing a handle object array"
    128128%kfold.feature   ={repmat(kml_placemark(),1,size(md.elements,1))};

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

    r9714 r9725  
    8080
    8181if exist('data','var') && ~isempty(data)
    82     if     (numel(data)==md.numberofelements)
     82    if     (numel(data)==md.mesh.numberofelements)
    8383        edata=data;
    84     elseif (numel(data)==md.numberofnodes)
     84    elseif (numel(data)==md.mesh.numberofvertices)
    8585        ndata=data;
    8686        display('Averaging nodal data to element data.');
    87         edata=zeros(1,md.numberofelements);
     87        edata=zeros(1,md.mesh.numberofelements);
    8888        for i=1:size(md.elements,1)
    8989            for j=1:size(md.elements,2)

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

    r9714 r9725  
    7575
    7676if exist('data','var') && ~isempty(data)
    77     if     (numel(data)==md.numberofelements)
     77    if     (numel(data)==md.mesh.numberofelements)
    7878        edata=data;
    79     elseif (numel(data)==md.numberofnodes)
     79    elseif (numel(data)==md.mesh.numberofvertices)
    8080        ndata=data;
    8181        display('Averaging nodal data to element data.');
    82         edata=zeros(1,md.numberofelements);
     82        edata=zeros(1,md.mesh.numberofelements);
    8383        for i=1:size(md.elements,1)
    8484            for j=1:size(md.elements,2)
    … …  
    123123    kfold.visibility=1;
    124124    kfold.descript  =sprintf('Partitions=%d, Nodes=%d',...
    125         md.qmu.numberofpartitions,md.numberofnodes);
     125        md.qmu.numberofpartitions,md.mesh.numberofvertices);
    126126    kfold.feature   ={repmat(kml_placemark(),1,md.qmu.numberofpartitions)};
    127127
    … …  
    150150        elemp=md.elements(irow,:);
    151151        epartp=epart(irow,:);
    152         nodeconp=nodeconnectivity(elemp,md.numberofnodes);
     152        nodeconp=nodeconnectivity(elemp,md.mesh.numberofvertices);
    153153        [edgeadjp]=edgeadjacency(elemp,nodeconp);
    154154        [edgeper,elemper,iloop]=edgeperimeter(elemp,nodeconp,edgeadjp);

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

    r9714 r9725  
    7575
    7676if exist('data','var') && ~isempty(data)
    77     if     (numel(data)==md.numberofelements)
     77    if     (numel(data)==md.mesh.numberofelements)
    7878        edata=data;
    79     elseif (numel(data)==md.numberofnodes)
     79    elseif (numel(data)==md.mesh.numberofvertices)
    8080        ndata=data;
    8181        display('Averaging nodal data to element data.');
    82         edata=zeros(1,md.numberofelements);
     82        edata=zeros(1,md.mesh.numberofelements);
    8383        for i=1:size(md.elements,1)
    8484            for j=1:size(md.elements,2)
    … …  
    123123    kfold.visibility=1;
    124124    kfold.descript  =sprintf('Partitions=%d, Nodes=%d\n',...
    125         md.qmu.numberofpartitions,md.numberofnodes);
     125        md.qmu.numberofpartitions,md.mesh.numberofvertices);
    126126    kfold.feature   ={repmat(kml_placemark(),1,md.qmu.numberofpartitions)};
    127127

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

    r9714 r9725  
    7676
    7777if exist('data','var') && ~isempty(data)
    78     if     (numel(data)==md.numberofelements)
     78    if     (numel(data)==md.mesh.numberofelements)
    7979        edata=data;
    80     elseif (numel(data)==md.numberofnodes)
     80    elseif (numel(data)==md.mesh.numberofvertices)
    8181        ndata=data;
    8282        display('Averaging nodal data to element data.');
    83         edata=zeros(1,md.numberofelements);
     83        edata=zeros(1,md.mesh.numberofelements);
    8484        for i=1:size(md.elements,1)
    8585            for j=1:size(md.elements,2)
    … …  
    124124    kfold.visibility=1;
    125125    kfold.descript  =sprintf('Partitions=%d, Nodes=%d',...
    126         md.qmu.numberofpartitions,md.numberofnodes);
     126        md.qmu.numberofpartitions,md.mesh.numberofvertices);
    127127    kfold.feature   ={repmat(kml_placemark(),1,md.qmu.numberofpartitions)};
    128128
    … …  
    151151        elemp=md.elements(irow,:);
    152152        epartp=epart(irow,:);
    153         nodeconp=nodeconnectivity(elemp,md.numberofnodes);
     153        nodeconp=nodeconnectivity(elemp,md.mesh.numberofvertices);
    154154        [edgeadjp]=edgeadjacency(elemp,nodeconp);
    155155        [edgeper,elemper,iloop]=edgeperimeter(elemp,nodeconp,edgeadjp);

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

    r9681 r9725  
    1717if ischar(domain),
    1818        if isempty(domain),
    19                 elementondomain=zeros(md.numberofelements,1);
    20                 vertexondomain=zeros(md.numberofnodes,1);
     19                elementondomain=zeros(md.mesh.numberofelements,1);
     20                vertexondomain=zeros(md.mesh.numberofvertices,1);
    2121                invert=0;
    2222        elseif strcmpi(domain,'all')
    23                 elementondomain=ones(md.numberofelements,1);
    24                 vertexondomain=ones(md.numberofnodes,1);
     23                elementondomain=ones(md.mesh.numberofelements,1);
     24                vertexondomain=ones(md.mesh.numberofvertices,1);
    2525                invert=0;
    2626        else
    … …  
    5555pos=find(~md.mask.elementonwater);
    5656numpos=unique(md.elements(pos,:));
    57 nodes=setdiff(1:1:md.numberofnodes,numpos);
     57nodes=setdiff(1:1:md.mesh.numberofvertices,numpos);
    5858md.diagnostic.spcvx(nodes)=md.inversion.vx_obs(nodes);
    5959md.diagnostic.spcvy(nodes)=md.inversion.vy_obs(nodes);

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

    r9681 r9725  
    1717if ischar(domain),
    1818        if isempty(domain),
    19                 elementondomain=zeros(md.numberofelements,1);
    20                 vertexondomain=zeros(md.numberofnodes,1);
     19                elementondomain=zeros(md.mesh.numberofelements,1);
     20                vertexondomain=zeros(md.mesh.numberofvertices,1);
    2121                invert=0;
    2222        elseif strcmpi(domain,'all')
    23                 elementondomain=ones(md.numberofelements,1);
    24                 vertexondomain=ones(md.numberofnodes,1);
     23                elementondomain=ones(md.mesh.numberofelements,1);
     24                vertexondomain=ones(md.mesh.numberofvertices,1);
    2525                invert=0;
    2626        else
    … …  
    5555pos=find(~md.mask.elementonwater);
    5656numpos=unique(md.elements(pos,:));
    57 nodes=setdiff(1:1:md.numberofnodes,numpos);
     57nodes=setdiff(1:1:md.mesh.numberofvertices,numpos);
    5858md.diagnostic.spcvx(nodes)=md.inversion.vx_obs(nodes);
    5959md.diagnostic.spcvy(nodes)=md.inversion.vy_obs(nodes);

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

    r9719 r9725  
    1414
    1515%nods data
    16 if (length(vector)==md.numberofnodes),
    17         vector_average=zeros(md.numberofnodes2d,1);
    18         for i=1:md.numlayers-1,
     16if (length(vector)==md.mesh.numberofvertices),
     17        vector_average=zeros(md.mesh.numberofvertices2d,1);
     18        for i=1:md.mesh.numberoflayers-1,
    1919                vector_average=vector_average+(project2d(md,vector,i)+project2d(md,vector,i+1))/2.*(project2d(md,md.z,i+1)-project2d(md,md.z,i));
    2020        end
    … …  
    2222
    2323%element data
    24 elseif (length(vector)==md.numberofelements),
    25         vector_average=zeros(md.numberofelements2d,1);
    26         for i=1:md.numlayers-1,
     24elseif (length(vector)==md.mesh.numberofelements),
     25        vector_average=zeros(md.mesh.numberofelements2d,1);
     26        for i=1:md.mesh.numberoflayers-1,
    2727                vector_average=vector_average+project2d(md,vector,i).*(project2d(md,md.z,i+1)-project2d(md,md.z,i));
    2828        end

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

    r8298 r9725  
    66
    77nnz=0;
    8 for i=1:md.numberofnodes,
     8for i=1:md.mesh.numberofvertices,
    99        nnz=nnz+length(find(md.elements==i));
    1010end
    11 conn=nnz/md.numberofnodes;
     11conn=nnz/md.mesh.numberofvertices;

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

    r9719 r9725  
    1616%      pressure=averaging(md,md.initialization.pressure,0);
    1717
    18 if length(data)~=md.numberofelements & length(data)~=md.numberofnodes
     18if length(data)~=md.mesh.numberofelements & length(data)~=md.mesh.numberofvertices
    1919        error('averaging error message: data not supported yet');
    2020end
    2121
    2222%initialization
    23 weights=zeros(md.numberofnodes,1);
     23weights=zeros(md.mesh.numberofvertices,1);
    2424data=data(:);
    2525
    2626%load some variables (it is much faster if the variab;es are loaded from md once for all)
    2727index=md.elements;
    28 numberofnodes=md.numberofnodes;
    29 numberofelements=md.numberofelements;
     28numberofnodes=md.mesh.numberofvertices;
     29numberofelements=md.mesh.numberofelements;
    3030
    3131%build some variables

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

    r9719 r9725  
    265265
    266266% Bamg Mesh parameters {{{1
    267 if (~exist(options,'domain') & md.numberofnodes~=0 & md.mesh.dimension==2),
     267if (~exist(options,'domain') & md.mesh.numberofvertices~=0 & md.mesh.dimension==2),
    268268
    269269        if isstruct(md.private.bamg),
    270270                bamg_mesh=bamgmesh(md.private.bamg.mesh);
    271271        else
    272                 bamg_mesh.Vertices=[md.x md.y ones(md.numberofnodes,1)];
    273                 bamg_mesh.Triangles=[md.elements ones(md.numberofelements,1)];
     272                bamg_mesh.Vertices=[md.x md.y ones(md.mesh.numberofvertices,1)];
     273                bamg_mesh.Triangles=[md.elements ones(md.mesh.numberofelements,1)];
    274274        end
    275275
    … …  
    326326%Fill in rest of fields:
    327327md.mesh.dimension=2;
    328 md.numberofelements=size(md.elements,1);
    329 md.numberofnodes=length(md.x);
    330 md.z=zeros(md.numberofnodes,1);
    331 md.nodeonbed=ones(md.numberofnodes,1);
    332 md.mask.vertexonwater=zeros(md.numberofnodes,1);
    333 md.nodeonsurface=ones(md.numberofnodes,1);
    334 md.elementonbed=ones(md.numberofelements,1);
    335 md.elementonsurface=ones(md.numberofelements,1);
    336 md.mesh.vertexonboundary=zeros(md.numberofnodes,1); md.mesh.vertexonboundary(md.mesh.segments(:,1:2))=1;
     328md.mesh.numberofelements=size(md.elements,1);
     329md.mesh.numberofvertices=length(md.x);
     330md.z=zeros(md.mesh.numberofvertices,1);
     331md.nodeonbed=ones(md.mesh.numberofvertices,1);
     332md.mask.vertexonwater=zeros(md.mesh.numberofvertices,1);
     333md.nodeonsurface=ones(md.mesh.numberofvertices,1);
     334md.elementonbed=ones(md.mesh.numberofelements,1);
     335md.elementonsurface=ones(md.mesh.numberofelements,1);
     336md.mesh.vertexonboundary=zeros(md.mesh.numberofvertices,1); md.mesh.vertexonboundary(md.mesh.segments(:,1:2))=1;
    337337md.elementconnectivity=md.private.bamg.mesh.ElementConnectivity;
    338338md.elementconnectivity(find(isnan(md.elementconnectivity)))=0;
    339339
    340340%Check for orphan
    341 if any(~ismember(1:md.numberofnodes,sort(unique(md.elements(:)))))
     341if any(~ismember(1:md.mesh.numberofvertices,sort(unique(md.elements(:)))))
    342342        error('Output mesh has orphans. Decrease MaxCornerAngle to prevent outside points (ex: 0.01)');
    343343end

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

    r9691 r9725  
    99%      wb=basevert(md);
    1010
    11 alpha=zeros(md.numberofelements,3);
    12 beta=zeros(md.numberofelements,3);
    13 gamma=zeros(md.numberofelements,3);
     11alpha=zeros(md.mesh.numberofelements,3);
     12beta=zeros(md.mesh.numberofelements,3);
     13gamma=zeros(md.mesh.numberofelements,3);
    1414
    15 for n=1:md.numberofelements
     15for n=1:md.mesh.numberofelements
    1616        X=inv([md.x(md.elements(n,:)) md.y(md.elements(n,:)) ones(3,1)]);
    1717        alpha(n,:)=X(1,:);

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

    r9719 r9725  
    77%load some variables (it is much faster if the variab;es are loaded from md once for all)
    88if (md.mesh.dimension==2),
    9         numberofelements=md.numberofelements;
    10         numberofnodes=md.numberofnodes;
     9        numberofelements=md.mesh.numberofelements;
     10        numberofnodes=md.mesh.numberofvertices;
    1111        index=md.elements;
    1212        x=md.x; y=md.y;
    1313else
    14         numberofelements=md.numberofelements2d;
    15         numberofnodes=md.numberofnodes2d;
     14        numberofelements=md.mesh.numberofelements2d;
     15        numberofnodes=md.mesh.numberofvertices2d;
    1616        index=md.elements2d;
    1717        x=md.x2d; y=md.y2d;

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

    r9719 r9725  
    2626
    2727%observations
    28 if ~isnan(md.inversion.vx_obs), md.inversion.vx_obs=project2d(md,md.inversion.vx_obs,md.numlayers); end;
    29 if ~isnan(md.inversion.vy_obs), md.inversion.vy_obs=project2d(md,md.inversion.vy_obs,md.numlayers); end;
    30 if ~isnan(md.inversion.vel_obs), md.inversion.vel_obs=project2d(md,md.inversion.vel_obs,md.numlayers); end;
     28if ~isnan(md.inversion.vx_obs), md.inversion.vx_obs=project2d(md,md.inversion.vx_obs,md.mesh.numberoflayers); end;
     29if ~isnan(md.inversion.vy_obs), md.inversion.vy_obs=project2d(md,md.inversion.vy_obs,md.mesh.numberoflayers); end;
     30if ~isnan(md.inversion.vel_obs), md.inversion.vel_obs=project2d(md,md.inversion.vel_obs,md.mesh.numberoflayers); end;
    3131if ~isnan(md.surfaceforcings.mass_balance),
    32         md.surfaceforcings.mass_balance=project2d(md,md.surfaceforcings.mass_balance,md.numlayers);
     32        md.surfaceforcings.mass_balance=project2d(md,md.surfaceforcings.mass_balance,md.mesh.numberoflayers);
    3333end;
    34 if ~isnan(md.balancethickness.thickening_rate), md.balancethickness.thickening_rate=project2d(md,md.balancethickness.thickening_rate,md.numlayers); end;
     34if ~isnan(md.balancethickness.thickening_rate), md.balancethickness.thickening_rate=project2d(md,md.balancethickness.thickening_rate,md.mesh.numberoflayers); end;
    3535
    3636%results
    … …  
    4141
    4242%bedinfo and surface info
    43 md.elementonbed=ones(md.numberofelements2d,1);
    44 md.elementonsurface=ones(md.numberofelements2d,1);
    45 md.nodeonbed=ones(md.numberofnodes2d,1);
    46 md.nodeonsurface=ones(md.numberofnodes2d,1);
     43md.elementonbed=ones(md.mesh.numberofelements2d,1);
     44md.elementonsurface=ones(md.mesh.numberofelements2d,1);
     45md.nodeonbed=ones(md.mesh.numberofvertices2d,1);
     46md.nodeonsurface=ones(md.mesh.numberofvertices2d,1);
    4747
    4848%elementstype
    … …  
    5252
    5353%boundary conditions
    54 md.diagnostic.spcvx=project2d(md,md.diagnostic.spcvx,md.numlayers);
    55 md.diagnostic.spcvy=project2d(md,md.diagnostic.spcvy,md.numlayers);
    56 md.diagnostic.spcvz=project2d(md,md.diagnostic.spcvz,md.numlayers);
    57 md.prognostic.spcthickness=project2d(md,md.prognostic.spcthickness,md.numlayers);
    58 md.thermal.spctemperature=project2d(md,md.thermal.spctemperature,md.numlayers);
     54md.diagnostic.spcvx=project2d(md,md.diagnostic.spcvx,md.mesh.numberoflayers);
     55md.diagnostic.spcvy=project2d(md,md.diagnostic.spcvy,md.mesh.numberoflayers);
     56md.diagnostic.spcvz=project2d(md,md.diagnostic.spcvz,md.mesh.numberoflayers);
     57md.prognostic.spcthickness=project2d(md,md.prognostic.spcthickness,md.mesh.numberoflayers);
     58md.thermal.spctemperature=project2d(md,md.thermal.spctemperature,md.mesh.numberoflayers);
    5959
    6060%Extrusion of Neumann BC
    6161if ~isnan(md.diagnostic.icefront),
    62         numberofneumann2d=size(md.diagnostic.icefront,1)/md.numlayers;
     62        numberofneumann2d=size(md.diagnostic.icefront,1)/md.mesh.numberoflayers;
    6363        md.diagnostic.icefront=[md.diagnostic.icefront(1:numberofneumann2d,1:2) md.diagnostic.icefront(1:numberofneumann2d,5:6)]; %Add two columns on the first layer
    6464end
    … …  
    7676
    7777%Collapse the mesh
    78 nodes2d=md.numberofnodes2d;
    79 elements2d=md.numberofelements2d;
     78nodes2d=md.mesh.numberofvertices2d;
     79elements2d=md.mesh.numberofelements2d;
    8080
    8181%parameters
    … …  
    9393md.y=md.y2d;
    9494md.z=zeros(size(md.x2d));
    95 md.numberofnodes=md.numberofnodes2d;
    96 md.numberofelements=md.numberofelements2d;
     95md.mesh.numberofvertices=md.mesh.numberofvertices2d;
     96md.mesh.numberofelements=md.mesh.numberofelements2d;
    9797md.elements=md.elements2d;
    9898
    … …  
    105105md.y2d=NaN;
    106106md.elements2d=NaN;
    107 md.numberofelements2d=md.numberofelements;
    108 md.numberofnodes2d=md.numberofnodes;
    109 md.numlayers=0;
     107md.mesh.numberofelements2d=md.mesh.numberofelements;
     108md.mesh.numberofvertices2d=md.mesh.numberofvertices;
     109md.mesh.numberoflayers=0;
    110110
    111111%Update mesh type

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

    r9641 r9725  
    3535%Now, build the connectivity tables for this mesh.
    3636%Computing connectivity
    37 if size(md.nodeconnectivity,1)~=md.numberofnodes,
    38         md.nodeconnectivity=NodeConnectivity(md.elements,md.numberofnodes);
     37if size(md.nodeconnectivity,1)~=md.mesh.numberofvertices,
     38        md.nodeconnectivity=NodeConnectivity(md.elements,md.mesh.numberofvertices);
    3939end
    40 if size(md.elementconnectivity,1)~=md.numberofelements,
     40if size(md.elementconnectivity,1)~=md.mesh.numberofelements,
    4141        md.elementconnectivity=ElementConnectivity(md.elements,md.nodeconnectivity);
    4242end
    … …  
    5555        else
    5656                %get flag list of elements and nodes inside the contour
    57                 nodein=zeros(md.numberofnodes,1);
    58                 elemin=zeros(md.numberofelements,1);
     57                nodein=zeros(md.mesh.numberofvertices,1);
     58                elemin=zeros(md.mesh.numberofelements,1);
    5959               
    6060                pos=find(flags);

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

    r9691 r9725  
    1010        error('contourmassbalance error message: bad usage');
    1111end
    12 if ((length(md.initialization.vx)~=md.numberofnodes)|(length(md.initialization.vy)~=md.numberofnodes))
    13         error(['thicknessevolution error message: vx and vy should have a length of ' num2str(md.numberofnodes)])
     12if ((length(md.initialization.vx)~=md.mesh.numberofvertices)|(length(md.initialization.vy)~=md.mesh.numberofvertices))
     13        error(['thicknessevolution error message: vx and vy should have a length of ' num2str(md.mesh.numberofvertices)])
    1414end
    1515if ~exist(file),

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

    r9719 r9725  
    66
    77if (md.mesh.dimension==2),
    8         numberofelements=md.numberofelements;
    9         numberofnodes=md.numberofnodes;
     8        numberofelements=md.mesh.numberofelements;
     9        numberofnodes=md.mesh.numberofvertices;
    1010        index=md.elements;
    1111        x=md.x; y=md.y; z=md.z;
    1212else
    13         numberofelements=md.numberofelements2d;
    14         numberofnodes=md.numberofnodes2d;
     13        numberofelements=md.mesh.numberofelements2d;
     14        numberofnodes=md.mesh.numberofvertices2d;
    1515        index=md.elements2d;
    1616        x=md.x2d; y=md.y2d;

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

    r9719 r9725  
    8282elements3d=[];
    8383for i=1:numlayers-1,
    84         elements3d=[elements3d;[md.elements+(i-1)*md.numberofnodes md.elements+i*md.numberofnodes]]; %Create the elements of the 3d mesh for the non extruded part
     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
    8585end
    8686number_el3d=size(elements3d,1); %number of 3d nodes for the non extruded part of the mesh
    … …  
    8989lowernodes=NaN*ones(number_nodes3d,1);
    9090uppernodes=NaN*ones(number_nodes3d,1);
    91 lowernodes(md.numberofnodes+1:end)=1:(numlayers-1)*md.numberofnodes;
    92 uppernodes(1:(numlayers-1)*md.numberofnodes)=md.numberofnodes+1:number_nodes3d;
     91lowernodes(md.mesh.numberofvertices+1:end)=1:(numlayers-1)*md.mesh.numberofvertices;
     92uppernodes(1:(numlayers-1)*md.mesh.numberofvertices)=md.mesh.numberofvertices+1:number_nodes3d;
    9393md.lowernodes=lowernodes;
    9494md.uppernodes=uppernodes;
    … …  
    9797lowerelements=NaN*ones(number_el3d,1);
    9898upperelements=NaN*ones(number_el3d,1);
    99 lowerelements(md.numberofelements+1:end)=1:(numlayers-2)*md.numberofelements;
    100 upperelements(1:(numlayers-2)*md.numberofelements)=md.numberofelements+1:(numlayers-1)*md.numberofelements;
     99lowerelements(md.mesh.numberofelements+1:end)=1:(numlayers-2)*md.mesh.numberofelements;
     100upperelements(1:(numlayers-2)*md.mesh.numberofelements)=md.mesh.numberofelements+1:(numlayers-1)*md.mesh.numberofelements;
    101101md.lowerelements=lowerelements;
    102102md.upperelements=upperelements;
    … …  
    106106md.y2d=md.y;
    107107md.elements2d=md.elements;
    108 md.numberofelements2d=md.numberofelements;
    109 md.numberofnodes2d=md.numberofnodes;
     108md.mesh.numberofelements2d=md.mesh.numberofelements;
     109md.mesh.numberofvertices2d=md.mesh.numberofvertices;
    110110
    111111%Update mesh type
    … …  
    117117md.y=y3d;
    118118md.z=z3d;
    119 md.numberofelements=number_el3d;
    120 md.numberofnodes=number_nodes3d;
    121 md.numlayers=numlayers;
     119md.mesh.numberofelements=number_el3d;
     120md.mesh.numberofvertices=number_nodes3d;
     121md.mesh.numberoflayers=numlayers;
    122122
    123123%Ok, now deal with the other fields from the 2d mesh:
    … …  
    148148
    149149%bedinfo and surface info
    150 md.elementonbed=project3d(md,'vector',ones(md.numberofelements2d,1),'type','element','layer',1);
    151 md.elementonsurface=project3d(md,'vector',ones(md.numberofelements2d,1),'type','element','layer',md.numlayers-1);
    152 md.nodeonbed=project3d(md,'vector',ones(md.numberofnodes2d,1),'type','node','layer',1);
    153 md.nodeonsurface=project3d(md,'vector',ones(md.numberofnodes2d,1),'type','node','layer',md.numlayers);
     150md.elementonbed=project3d(md,'vector',ones(md.mesh.numberofelements2d,1),'type','element','layer',1);
     151md.elementonsurface=project3d(md,'vector',ones(md.mesh.numberofelements2d,1),'type','element','layer',md.mesh.numberoflayers-1);
     152md.nodeonbed=project3d(md,'vector',ones(md.mesh.numberofvertices2d,1),'type','node','layer',1);
     153md.nodeonsurface=project3d(md,'vector',ones(md.mesh.numberofvertices2d,1),'type','node','layer',md.mesh.numberoflayers);
    154154
    155155%elementstype
    … …  
    171171md.diagnostic.spcvy=project3d(md,'vector',md.diagnostic.spcvy,'type','node');
    172172md.diagnostic.spcvz=project3d(md,'vector',md.diagnostic.spcvz,'type','node');
    173 md.thermal.spctemperature=project3d(md,'vector',md.thermal.spctemperature,'type','node','layer',md.numlayers,'padding',NaN);
     173md.thermal.spctemperature=project3d(md,'vector',md.thermal.spctemperature,'type','node','layer',md.mesh.numberoflayers,'padding',NaN);
    174174md.prognostic.spcthickness=project3d(md,'vector',md.prognostic.spcthickness,'type','node');
    175175md.diagnostic.referential=project3d(md,'vector',md.diagnostic.referential,'type','node');
    176176
    177177%in 3d, pressureload: [node1 node2 node3 node4 element]
    178 pressureload_layer1=[md.diagnostic.icefront(:,1:2)  md.diagnostic.icefront(:,2)+md.numberofnodes2d  md.diagnostic.icefront(:,1)+md.numberofnodes2d  md.diagnostic.icefront(:,3:4)]; %Add two columns on the first layer
     178pressureload_layer1=[md.diagnostic.icefront(:,1:2)  md.diagnostic.icefront(:,2)+md.mesh.numberofvertices2d  md.diagnostic.icefront(:,1)+md.mesh.numberofvertices2d  md.diagnostic.icefront(:,3:4)]; %Add two columns on the first layer
    179179pressureload=[];
    180180for i=1:numlayers-1,
    181         pressureload=[pressureload ;pressureload_layer1(:,1:4)+(i-1)*md.numberofnodes2d pressureload_layer1(:,5)+(i-1)*md.numberofelements2d pressureload_layer1(:,6)];
     181        pressureload=[pressureload ;pressureload_layer1(:,1:4)+(i-1)*md.mesh.numberofvertices2d pressureload_layer1(:,5)+(i-1)*md.mesh.numberofelements2d pressureload_layer1(:,6)];
    182182end
    183183md.diagnostic.icefront=pressureload;
    … …  
    187187md.elementconnectivity(find(md.elementconnectivity==0))=NaN;
    188188for i=2:numlayers-1,
    189         md.elementconnectivity((i-1)*md.numberofelements2d+1:(i)*md.numberofelements2d,:)...
    190         =md.elementconnectivity((i-1)*md.numberofelements2d+1:(i)*md.numberofelements2d,:)+md.numberofelements2d;
     189        md.elementconnectivity((i-1)*md.mesh.numberofelements2d+1:(i)*md.mesh.numberofelements2d,:)...
     190        =md.elementconnectivity((i-1)*md.mesh.numberofelements2d+1:(i)*md.mesh.numberofelements2d,:)+md.mesh.numberofelements2d;
    191191end
    192192md.elementconnectivity(find(isnan(md.elementconnectivity)))=0;

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

    r9719 r9725  
    2424        end
    2525        %   probably going to need some checks on flaim.flightreqs here
    26         if (numel(md.flaim.criterion) ~= md.numberofnodes) && (numel(md.flaim.criterion) ~= md.numberofelements)
    27                 message(['model not consistent: flaim.criterion vector must have number of nodes (' int2str(md.numberofnodes) ') or elements (' int2str(md.numberofelements) ') values, not ' int2str(numel(md.flaim.criterion)) ' values.']);
     26        if (numel(md.flaim.criterion) ~= md.mesh.numberofvertices) && (numel(md.flaim.criterion) ~= md.mesh.numberofelements)
     27                message(['model not consistent: flaim.criterion vector must have number of nodes (' int2str(md.mesh.numberofvertices) ') or elements (' int2str(md.mesh.numberofelements) ') values, not ' int2str(numel(md.flaim.criterion)) ' values.']);
    2828        end
    2929        return;
    … …  
    5050fields={'elements'};
    5151if (md.mesh.dimension==2),
    52         checksize(md,fields,[md.numberofelements 3]);
     52        checksize(md,fields,[md.mesh.numberofelements 3]);
    5353else
    54         checksize(md,fields,[md.numberofelements 6]);
    55 end
    56 if any(~ismember(1:md.numberofnodes,sort(unique(md.elements(:)))));
     54        checksize(md,fields,[md.mesh.numberofelements 6]);
     55end
     56if any(~ismember(1:md.mesh.numberofvertices,sort(unique(md.elements(:)))));
    5757        message('orphan nodes have been found. Check the mesh');
    5858end
    … …  
    8282%}}}
    8383%NO NAN {{{1
    84 fields={'numberofelements','numberofnodes','x','y','z','friction.coefficient','friction.p','friction.q',...
     84fields={'mesh.numberofelements','mesh.numberofvertices','x','y','z','friction.coefficient','friction.p','friction.q',...
    8585        'materials.rho_ice','materials.rho_water','materials.rheology_B','mask.elementonfloatingice','geometry.surface','geometry.thickness','geometry.bed','constants.g','settings.lowmem','inversion.nsteps','inversion.maxiter_per_step',...
    8686        'diagnostic.restol','diagnostic.maxiter','materials.rheology_n','nodeonbed','nodeonsurface','elementonbed','elementonsurface','elementconnectivity'};
    … …  
    8888%}}}}
    8989%FIELDS >= 0 {{{1
    90 fields={'numberofelements','numberofnodes','elements','friction.coefficient','friction.p','friction.q',...
     90fields={'mesh.numberofelements','mesh.numberofvertices','elements','friction.coefficient','friction.p','friction.q',...
    9191        'materials.rho_ice','materials.rho_water','materials.rheology_B','mask.elementonfloatingice','geometry.thickness','constants.g','diagnostic.restol','diagnostic.maxiter','diagnostic.reltol',...
    9292        'diagnostic.abstol','inversion.nsteps','inversion.maxiter_per_step',...
    … …  
    9595%}}}
    9696%FIELDS > 0 {{{1
    97 fields={'numberofelements','numberofnodes','elements','friction.p',...
     97fields={'mesh.numberofelements','mesh.numberofvertices','elements','friction.p',...
    9898        'materials.rho_ice','materials.rho_water','materials.rheology_B','geometry.thickness','constants.g','diagnostic.maxiter','diagnostic.restol','diagnostic.reltol','diagnostic.abstol','inversion.maxiter_per_step'};
    9999checkgreaterstrict(md,fields,0);
    … …  
    101101%SIZE NUMBEROFELEMENTS {{{1
    102102fields={'friction.p','friction.q','mask.elementonfloatingice','materials.rheology_n','elementonbed'};
    103 checksize(md,fields,[md.numberofelements 1]);
     103checksize(md,fields,[md.mesh.numberofelements 1]);
    104104%}}}
    105105%SIZE NUMBEROFNODES {{{1
    106106fields={'x','y','z','materials.rheology_B','friction.coefficient','basalforcings.melting_rate','geometry.surface','geometry.thickness','geometry.bed','nodeonbed','nodeonsurface'};
    107 checksize(md,fields,[md.numberofnodes 1]);
     107checksize(md,fields,[md.mesh.numberofvertices 1]);
    108108%}}}
    109109%OTHER SIZES {{{1
    110110fields={'diagnostic.referential'};
    111 checksize(md,fields,[md.numberofnodes 6]);
     111checksize(md,fields,[md.mesh.numberofvertices 6]);
    112112if ~isempty(md.diagnostic.requested_outputs),
    113113        if(size(md.diagnostic.requested_outputs,2)~=1),
    … …  
    222222        checksize(md,fields,[md.inversion.nsteps num_controls]);
    223223        fields={'inversion.min_parameters','inversion.max_parameters'};
    224         checksize(md,fields,[md.numberofnodes num_controls]);
     224        checksize(md,fields,[md.mesh.numberofvertices num_controls]);
    225225
    226226        %RESPONSES
    … …  
    229229        %WEIGHTS
    230230        fields={'inversion.cost_functions_coefficients'};
    231         checksize(md,fields,[md.numberofnodes num_costfunc]);
     231        checksize(md,fields,[md.mesh.numberofvertices num_costfunc]);
    232232        checkgreater(md,fields,0);
    233233
    … …  
    235235        if md.private.solution==BalancethicknessSolutionEnum
    236236                fields={'inversion.thickness_obs'};
    237                 checksize(md,fields,[md.numberofnodes 1]);
     237                checksize(md,fields,[md.mesh.numberofvertices 1]);
    238238                checknan(md,fields);
    239239        else
    240240                fields={'inversion.vx_obs','inversion.vy_obs'};
    241                 checksize(md,fields,[md.numberofnodes 1]);
     241                checksize(md,fields,[md.mesh.numberofvertices 1]);
    242242                checknan(md,fields);
    243243        end
    … …  
    258258        end
    259259        if ~isempty(md.qmu.partition),
    260                 if numel(md.qmu.partition)~=md.numberofnodes,
    261                         message(['model not consistent: user supplied partition for qmu analysis should have size md.numberofnodes x 1 ']);
    262                 end
    263                 if find(md.qmu.partition)>=md.numberofnodes,
     260                if numel(md.qmu.partition)~=md.mesh.numberofvertices,
     261                        message(['model not consistent: user supplied partition for qmu analysis should have size md.mesh.numberofvertices x 1 ']);
     262                end
     263                if find(md.qmu.partition)>=md.mesh.numberofvertices,
    264264                        message(['model not consistent: user supplied partition should be indexed from 0 (c-convention)']);
    265265                end
    … …  
    267267                        message(['model not consistent: partition vector not indexed from 0 on']);
    268268                end
    269                 if max(md.qmu.partition)>=md.numberofnodes,
     269                if max(md.qmu.partition)>=md.mesh.numberofvertices,
    270270                        message(['model not consistent: partition vector cannot have maximum index larger than number of nodes']);
    271271                end
    … …  
    333333%}}}
    334334%GROUNDINGLINEMIGRATION2D{{{1
    335 if md.private.solution==GroundinglineMigration2DSolutionEnum,
     335if md.private.solution==GroundinglineMigration2dSolutionEnum,
    336336        if strcmpi(md.cluster.name,'none'),
    337337                message(['model not consistent: ' md.private.solution ' is only implemented in parallel mode !'])
    … …  
    401401                                fields={'initialization.vx','initialization.vy'};
    402402                                checknan(md,fields);
    403                                 checksize(md,fields,[md.numberofnodes 1]);
     403                                checksize(md,fields,[md.mesh.numberofvertices 1]);
    404404                        end
    405405
    … …  
    407407                        %Check the size of flowequation.element_equation
    408408                        fields={'flowequation.element_equation'};
    409                         checksize(md,fields,[md.numberofelements 1]);
     409                        checksize(md,fields,[md.mesh.numberofelements 1]);
    410410                        %Check the values of flowequation.element_equation
    411411                        checkvalues(md,{'flowequation.element_equation'},[0:7]);
    … …  
    420420                        %Check the size of verticess_type
    421421                        fields={'flowequation.vertex_equation'};
    422                         checksize(md,fields,[md.numberofnodes 1]);
     422                        checksize(md,fields,[md.mesh.numberofvertices 1]);
    423423                        %Check the values of flowequation.vertex_equation
    424424                        checkvalues(md,{'flowequation.vertex_equation'},[0:7]);
    … …  
    455455                        %INITIAL VELOCITIES
    456456                        fields={'initialization.vx','initialization.vy'};
    457                         checksize(md,fields,[md.numberofnodes 1]);
     457                        checksize(md,fields,[md.mesh.numberofvertices 1]);
    458458                        checknan(md,fields);
    459459
    … …  
    481481                        checkforcing(md,fields);
    482482                        fields={'initialization.watercolumn'};
    483                         checksize(md,fields,[md.numberofnodes 1]);
     483                        checksize(md,fields,[md.mesh.numberofvertices 1]);
    484484                        %}}}
    485485                case ThermalAnalysisEnum,
    … …  
    505505                        %VELOCITIES AND PRESSURE
    506506                        fields={'initialization.vx','initialization.vy','initialization.vz','initialization.pressure','basalforcings.geothermalflux'};
    507                         checksize(md,fields,[md.numberofnodes 1]);
     507                        checksize(md,fields,[md.mesh.numberofvertices 1]);
    508508                        checknan(md,fields);
    509509
    … …  
    517517                                %INITIAL TEMPERATURE, MELTING AND ACCUMULATION
    518518                                fields={'initialization.temperature','basalforcings.melting_rate'};
    519                                 checksize(md,fields,[md.numberofnodes 1]);
     519                                checksize(md,fields,[md.mesh.numberofvertices 1]);
    520520                                checknan(md,fields);
    521521
    … …  
    525525
    526526                                %CHECK SPCTEMPERATURE that are not NaN are >0.
    527                                 if find(any(md.thermal.spctemperature(find(~isnan(md.thermal.spctemperature(1:md.numberofnodes,:))))<=0)),
     527                                if find(any(md.thermal.spctemperature(find(~isnan(md.thermal.spctemperature(1:md.mesh.numberofvertices,:))))<=0)),
    528528                                        message(['model not consistent: model ' md.miscellaneous.name ' is constrained with negative or nil temperatures!']);
    529529                                end
    … …  
    544544                        %VELOCITIES AND PRESSURE
    545545                        fields={'initialization.vx','initialization.vy','initialization.vz','initialization.pressure','basalforcings.geothermalflux'};
    546                         checksize(md,fields,[md.numberofnodes 1]);
     546                        checksize(md,fields,[md.mesh.numberofvertices 1]);
    547547                        checknan(md,fields);
    548548
    … …  
    556556                                %INITIAL TEMPERATURE, MELTING, ACCUMULATION AND WATERFRACTION
    557557                                fields={'initialization.temperature','basalforcings.melting_rate','initialization.waterfraction'};
    558                                 checksize(md,fields,[md.numberofnodes 1]);
     558                                checksize(md,fields,[md.mesh.numberofvertices 1]);
    559559                                checknan(md,fields);
    560560
    … …  
    572572                        %VELOCITIES MELTING AND ACCUMULATION
    573573                        fields={'initialization.vx','initialization.vy','basalforcings.melting_rate','balancethickness.thickening_rate'};
    574                         checksize(md,fields,[md.numberofnodes 1]);
     574                        checksize(md,fields,[md.mesh.numberofvertices 1]);
    575575                        checknan(md,fields);
    576576
    … …  
    622622                                if strcmp(fields{i},'cm_min'),
    623623                                        disp('!!! ');
    624                                         disp('!!! WARNING: cm_min must now be of size [md.numberofnodes x 1]. Update your parameter file as follows:');
     624                                        disp('!!! WARNING: cm_min must now be of size [md.mesh.numberofvertices x 1]. Update your parameter file as follows:');
    625625                                        disp('!!! ');
    626                                         disp('!!! md.inversion.min_parameters=md.inversion.min_parameters*ones(md.numberofnodes,1);');
     626                                        disp('!!! md.inversion.min_parameters=md.inversion.min_parameters*ones(md.mesh.numberofvertices,1);');
    627627                                        disp('!!! ');
    628628                                end
    … …  
    630630                                if strcmp(fields{i},'cm_max'),
    631631                                        disp('!!! ');
    632                                         disp('!!! WARNING: cm_max must now be of size [md.numberofnodes x 1]. Update your parameter file as follows:');
     632                                        disp('!!! WARNING: cm_max must now be of size [md.mesh.numberofvertices x 1]. Update your parameter file as follows:');
    633633                                        disp('!!! ');
    634                                         disp('!!! md.inversion.max_parameters=md.inversion.max_parameters*ones(md.numberofnodes,1);');
     634                                        disp('!!! md.inversion.max_parameters=md.inversion.max_parameters*ones(md.mesh.numberofvertices,1);');
    635635                                        disp('!!! ');
    636636                                end
    … …  
    723723        for i=1:length(fields),
    724724                eval(['field=md.' fields{i} ';']);
    725                 if size(field,1)==md.numberofnodes,
     725                if size(field,1)==md.mesh.numberofvertices,
    726726                        if ~size(field,2)==1,
    727                                 message(['model not consistent: model ' md.miscellaneous.name ': ' fields{i} ' should have only one column as there are md.numberofnodes lines']);
    728                         end
    729                 elseif size(field,1)==md.numberofnodes+1
     727                                message(['model not consistent: model ' md.miscellaneous.name ': ' fields{i} ' should have only one column as there are md.mesh.numberofvertices lines']);
     728                        end
     729                elseif size(field,1)==md.mesh.numberofvertices+1
    730730                        if any(field(end,:)~=sort(field(end,:))),
    731731                                message(['model not consistent: model ' md.miscellaneous.name ': ' fields{i} ' columns should be chronological']);
    … …  
    735735                        end
    736736                else
    737                         message(['model not consistent: model ' md.miscellaneous.name ': ' fields{i} ' should have md.numberofnodes or md.numberofnodes+1 lines']);
     737                        message(['model not consistent: model ' md.miscellaneous.name ': ' fields{i} ' should have md.mesh.numberofvertices or md.mesh.numberofvertices+1 lines']);
    738738                end
    739739        end

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

    r9683 r9725  
    1919template=model.template();
    2020MarshallObject(fid,template,md,'');
    21 
    22 %FIXME add some fields needed by parameters
    23 WriteData(fid,'numberofedges',size(md.edges,1),modelfield('format','Integer'));
    2421
    2522%close file
    … …  
    272269%      enum=BuildEnum(string)
    273270
    274 %FIXME: delete this one
    275 if strcmp(string,'Numberofnodes'),
    276         string='Numberofvertices';
    277 end
    278 
    279 if strncmpi(string,'numberof',8),
    280         string(1:8)='NumberOf';
    281         string(9)=upper(string(9));
    282 end
    283 
    284271if findstr(string,'_'),
    285272        indices=findstr(string,'_');
    … …  
    288275        end
    289276        string(indices)=[];
    290 end
    291 
    292 if findstr(string,'2d'),
    293         indices=findstr(string,'2d');
    294         for i=1:length(indices),
    295                 string(indices(i)+1)=upper(string(indices(i)+1));
    296         end
    297 end
    298 
    299 if findstr(string,'3d'),
    300         indices=findstr(string,'3d');
    301         for i=1:length(indices),
    302                 string(indices(i)+1)=upper(string(indices(i)+1));
    303         end
    304277end
    305278

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

    r9719 r9725  
    1414
    1515%some checks
    16 if length(vx)~=md.numberofnodes | length(vy)~=md.numberofnodes,
    17         error(['the input velocity should be of size ' num2str(md.numberofnodes) '!'])
     16if length(vx)~=md.mesh.numberofvertices | length(vy)~=md.mesh.numberofvertices,
     17        error(['the input velocity should be of size ' num2str(md.mesh.numberofvertices) '!'])
    1818end
    1919if ~(md.mesh.dimension==2)
    … …  
    2525
    2626%initialization
    27 numberofelements=md.numberofelements;
     27numberofelements=md.mesh.numberofelements;
    2828index=md.elements;
    2929summation=[1;1;1];

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

    r8298 r9725  
    1515
    1616%Now, build the connectivity tables for this mesh if not correclty done
    17 if size(md.elementconnectivity,1)~=md.numberofelements,
     17if size(md.elementconnectivity,1)~=md.mesh.numberofelements,
    1818        if exist(options,'elementconnectivity'),
    1919                error(' ''elementconnectivity'' option does not have thge right size.');

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

    r9719 r9725  
    1717        error('meshadaptation error message: adaptation for 3d meshes not implemented yet')
    1818end
    19 if length(field)~=md.numberofnodes
     19if length(field)~=md.mesh.numberofvertices
    2020        error('meshadaptation error message: input field length shoud be numberofnodes')
    2121end
    … …  
    2525%initialization
    2626index=md.elements;
    27 numberofnodes=md.numberofnodes;
    28 numberofelements=md.numberofelements;
     27numberofnodes=md.mesh.numberofvertices;
     28numberofelements=md.mesh.numberofelements;
    2929gradx=zeros(numberofnodes,1);
    3030grady=zeros(numberofnodes,1);
    … …  
    9090
    9191%Remesh with this new metric
    92 disp(sprintf('      initial number of element: %i', md.numberofelements))
     92disp(sprintf('      initial number of element: %i', md.mesh.numberofelements))
    9393md2=meshrefine(md,full(metric));
    9494disp(sprintf('      new number of elements:    %i', md2.numberofelements))

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

    r9703 r9725  
    5353disp('Initial mesh generation...');
    5454md=setmesh(md,domainoutline,resolution);
    55 disp(['Initial mesh, number of elements: ' num2str(md.numberofelements)]);
     55disp(['Initial mesh, number of elements: ' num2str(md.mesh.numberofelements)]);
    5656
    5757%load velocities
    … …  
    9898        if ~strcmp(groundeddomain,'N/A'),
    9999                nodeground=ContourToMesh(md.elements,md.x,md.y,groundeddomain,'node',2);
    100                 md.nodeonwater=ones(md.numberofnodes,1);
     100                md.nodeonwater=ones(md.mesh.numberofvertices,1);
    101101                md.nodeonwater(find(nodeground))=0;
    102102        else
    103                 md.nodeonwater=zeros(md.numberofnodes,1);
     103                md.nodeonwater=zeros(md.mesh.numberofvertices,1);
    104104        end
    105105
    … …  
    110110end
    111111       
    112 disp(['Final mesh, number of elements: ' num2str(md.numberofelements)]);
     112disp(['Final mesh, number of elements: ' num2str(md.mesh.numberofelements)]);

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

    r9719 r9725  
    3737%Fill in rest of fields:
    3838md.mesh.dimension=2;
    39 md.numberofelements=size(md.elements,1);
    40 md.numberofnodes=length(md.x);
    41 md.z=zeros(md.numberofnodes,1);
    42 md.nodeonbed=ones(md.numberofnodes,1);
    43 md.mask.vertexonwater=zeros(md.numberofnodes,1);
    44 md.nodeonsurface=ones(md.numberofnodes,1);
    45 md.elementonbed=ones(md.numberofelements,1);
    46 md.elementonsurface=ones(md.numberofelements,1);
    47 md.mesh.vertexonboundary=zeros(md.numberofnodes,1); md.mesh.vertexonboundary(md.mesh.segments(:,1:2))=1;
     39md.mesh.numberofelements=size(md.elements,1);
     40md.mesh.numberofvertices=length(md.x);
     41md.z=zeros(md.mesh.numberofvertices,1);
     42md.nodeonbed=ones(md.mesh.numberofvertices,1);
     43md.mask.vertexonwater=zeros(md.mesh.numberofvertices,1);
     44md.nodeonsurface=ones(md.mesh.numberofvertices,1);
     45md.elementonbed=ones(md.mesh.numberofelements,1);
     46md.elementonsurface=ones(md.mesh.numberofelements,1);
     47md.mesh.vertexonboundary=zeros(md.mesh.numberofvertices,1); md.mesh.vertexonboundary(md.mesh.segments(:,1:2))=1;

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

    r9719 r9725  
    5555
    5656%Fill in rest of fields:
    57 md.numberofelements=length(md.elements);
    58 md.numberofnodes=length(md.x);
    59 md.z=zeros(md.numberofnodes,1);
    60 md.mesh.vertexonboundary=zeros(md.numberofnodes,1); md.mesh.vertexonboundary(md.mesh.segments(:,1:2))=1;
    61 md.nodeonbed=ones(md.numberofnodes,1);
    62 md.nodeonsurface=ones(md.numberofnodes,1);
    63 md.elementonbed=ones(md.numberofelements,1);
    64 md.elementonsurface=ones(md.numberofelements,1);
     57md.mesh.numberofelements=length(md.elements);
     58md.mesh.numberofvertices=length(md.x);
     59md.z=zeros(md.mesh.numberofvertices,1);
     60md.mesh.vertexonboundary=zeros(md.mesh.numberofvertices,1); md.mesh.vertexonboundary(md.mesh.segments(:,1:2))=1;
     61md.nodeonbed=ones(md.mesh.numberofvertices,1);
     62md.nodeonsurface=ones(md.mesh.numberofvertices,1);
     63md.elementonbed=ones(md.mesh.numberofelements,1);
     64md.elementonsurface=ones(md.mesh.numberofelements,1);
    6565
    6666%Now, build the connectivity tables for this mesh.
    67 md.nodeconnectivity=NodeConnectivity(md.elements,md.numberofnodes);
     67md.nodeconnectivity=NodeConnectivity(md.elements,md.mesh.numberofvertices);
    6868md.elementconnectivity=ElementConnectivity(md.elements,md.nodeconnectivity);
    6969

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

    r9719 r9725  
    1010        error('meshrefine error message');
    1111end
    12 if ( (isempty(areas)) |  (length(areas)~=md.numberofelements) | (length(find(isnan(areas))))),
     12if ( (isempty(areas)) |  (length(areas)~=md.mesh.numberofelements) | (length(find(isnan(areas))))),
    1313        meshrefineusage();
    1414        error('meshrefine error message');
    … …  
    1919
    2020%Fill in rest of fields:
    21 md.numberofelements=length(md.elements);
    22 md.numberofnodes=length(md.x);
    23 md.z=zeros(md.numberofnodes,1);
    24 md.mesh.vertexonboundary=zeros(md.numberofnodes,1); md.mesh.vertexonboundary(md.mesh.segments(:,1:2))=1;
    25 md.nodeonbed=ones(md.numberofnodes,1);
    26 md.nodeonsurface=ones(md.numberofnodes,1);
    27 md.elementonbed=ones(md.numberofelements,1);
    28 md.elementonsurface=ones(md.numberofelements,1);
     21md.mesh.numberofelements=length(md.elements);
     22md.mesh.numberofvertices=length(md.x);
     23md.z=zeros(md.mesh.numberofvertices,1);
     24md.mesh.vertexonboundary=zeros(md.mesh.numberofvertices,1); md.mesh.vertexonboundary(md.mesh.segments(:,1:2))=1;
     25md.nodeonbed=ones(md.mesh.numberofvertices,1);
     26md.nodeonsurface=ones(md.mesh.numberofvertices,1);
     27md.elementonbed=ones(md.mesh.numberofelements,1);
     28md.elementonsurface=ones(md.mesh.numberofelements,1);
    2929
    3030%Now, build the connectivity tables for this mesh.
    31 md.nodeconnectivity=NodeConnectivity(md.elements,md.numberofnodes);
     31md.nodeconnectivity=NodeConnectivity(md.elements,md.mesh.numberofvertices);
    3232md.elementconnectivity=ElementConnectivity(md.elements,md.nodeconnectivity);
    3333

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

    r9714 r9725  
    5757        md=meshprocessrifts(md,domainoutline);
    5858end
    59 disp(['Initial mesh, number of elements: ' num2str(md.numberofelements)]);
     59disp(['Initial mesh, number of elements: ' num2str(md.mesh.numberofelements)]);
    6060
    6161%load velocities
    … …  
    8282        if ~strcmp(groundeddomain,'N/A'),
    8383                nodeground=ContourToMesh(md.elements,md.x,md.y,groundeddomain,'node',2);
    84                 md.nodeonwater=ones(md.numberofnodes,1);
     84                md.nodeonwater=ones(md.mesh.numberofvertices,1);
    8585                md.nodeonwater(find(nodeground))=0;
    8686        else
    87                 md.nodeonwater=zeros(md.numberofnodes,1);
     87                md.nodeonwater=zeros(md.mesh.numberofvertices,1);
    8888        end
    8989
    … …  
    9595        %rifts, because the segments are used in YamsCall to freeze the rifts elements during refinement.
    9696        if md.rifts.numrifts,
    97                 md.nodeconnectivity=NodeConnectivity(md.elements,md.numberofnodes);
     97                md.nodeconnectivity=NodeConnectivity(md.elements,md.mesh.numberofvertices);
    9898                md.elementconnectivity=ElementConnectivity(md.elements,md.nodeconnectivity);
    9999                md.mesh.segments=findsegments(md);
    … …  
    103103end
    104104       
    105 disp(['Final mesh, number of elements: ' num2str(md.numberofelements)]);
     105disp(['Final mesh, number of elements: ' num2str(md.mesh.numberofelements)]);
    106106
    107107%Now, build the connectivity tables for this mesh.
    108 md.nodeconnectivity=NodeConnectivity(md.elements,md.numberofnodes);
     108md.nodeconnectivity=NodeConnectivity(md.elements,md.mesh.numberofvertices);
    109109md.elementconnectivity=ElementConnectivity(md.elements,md.nodeconnectivity);
    110110
    111111%recreate segments
    112112md.mesh.segments=findsegments(md);
    113 md.mesh.vertexonboundary=zeros(md.numberofnodes,1); md.mesh.vertexonboundary(md.mesh.segments(:,1:2))=1;
     113md.mesh.vertexonboundary=zeros(md.mesh.numberofvertices,1); md.mesh.vertexonboundary(md.mesh.segments(:,1:2))=1;
    114114
    115115%Fill in rest of fields:
    116 md.z=zeros(md.numberofnodes,1);
    117 md.nodeonbed=ones(md.numberofnodes,1);
    118 md.nodeonsurface=ones(md.numberofnodes,1);
    119 md.elementonbed=ones(md.numberofelements,1);
    120 md.elementonsurface=ones(md.numberofelements,1);
     116md.z=zeros(md.mesh.numberofvertices,1);
     117md.nodeonbed=ones(md.mesh.numberofvertices,1);
     118md.nodeonsurface=ones(md.mesh.numberofvertices,1);
     119md.elementonbed=ones(md.mesh.numberofelements,1);
     120md.elementonsurface=ones(md.mesh.numberofelements,1);
    121121if ~strcmp(groundeddomain,'N/A'),
    122122        nodeground=ContourToMesh(md.elements,md.x,md.y,groundeddomain,'node',2);
    123         md.nodeonwater=ones(md.numberofnodes,1);
     123        md.nodeonwater=ones(md.mesh.numberofvertices,1);
    124124        md.nodeonwater(find(nodeground))=0;
    125125else
    126         md.nodeonwater=zeros(md.numberofnodes,1);
     126        md.nodeonwater=zeros(md.mesh.numberofvertices,1);
    127127end
    128128if strcmpi(Names.interp,'node'),

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

    r9719 r9725  
    1212
    1313%reorder elements
    14 newelements=randperm(md.numberofelements)';
    15 tnewelements=zeros(md.numberofelements,1);tnewelements(newelements)=[1:md.numberofelements]';
     14newelements=randperm(md.mesh.numberofelements)';
     15tnewelements=zeros(md.mesh.numberofelements,1);tnewelements(newelements)=[1:md.mesh.numberofelements]';
    1616
    1717%reorder nodes
    18 newnodes=randperm(md.numberofnodes)';
    19 tnewnodes=zeros(md.numberofnodes,1);tnewnodes(newnodes)=[1:md.numberofnodes]';
     18newnodes=randperm(md.mesh.numberofvertices)';
     19tnewnodes=zeros(md.mesh.numberofvertices,1);tnewnodes(newnodes)=[1:md.mesh.numberofvertices]';
    2020
    2121%update all fields
    … …  
    2525md.y=md.y(newnodes);
    2626md.z=md.z(newnodes);
    27 md.mesh.vertexonboundary=zeros(md.numberofnodes,1); md.mesh.vertexonboundary(md.mesh.segments(:,1:2))=1;
     27md.mesh.vertexonboundary=zeros(md.mesh.numberofvertices,1); md.mesh.vertexonboundary(md.mesh.segments(:,1:2))=1;

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

    r9719 r9725  
    5656       
    5757        %plug md2 mesh into md mesh:
    58         [md.elements,md.x,md.y,md.z,md.numberofelements,md.numberofnodes,elconv,nodeconv,elconv2,nodeconv2]=meshplug(md.elements,md.x,md.y,md.z,...
     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,...
    5959                                                                md2.elements,md2.x,md2.y,md2.z,md2.extractednodes,md2.extractedelements,domain_index);
    6060
    … …  
    8080
    8181%finish up "a la" mesh.h
    82 md.mesh.vertexonboundary=zeros(md.numberofnodes,1); md.mesh.vertexonboundary(md.mesh.segments(:,1:2))=1;
    83 md.nodeonbed=ones(md.numberofnodes,1);
    84 md.nodeonsurface=ones(md.numberofnodes,1);
    85 md.elementonbed=ones(md.numberofelements,1);
    86 md.elementonsurface=ones(md.numberofelements,1);
     82md.mesh.vertexonboundary=zeros(md.mesh.numberofvertices,1); md.mesh.vertexonboundary(md.mesh.segments(:,1:2))=1;
     83md.nodeonbed=ones(md.mesh.numberofvertices,1);
     84md.nodeonsurface=ones(md.mesh.numberofvertices,1);
     85md.elementonbed=ones(md.mesh.numberofelements,1);
     86md.elementonsurface=ones(md.mesh.numberofelements,1);
    8787
    8888%Now, build the connectivity tables for this mesh.
    89 md.nodeconnectivity=NodeConnectivity(md.elements,md.numberofnodes);
     89md.nodeconnectivity=NodeConnectivity(md.elements,md.mesh.numberofvertices);
    9090md.elementconnectivity=ElementConnectivity(md.elements,md.nodeconnectivity);
    9191

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

    r9714 r9725  
    5858                md.x=[md.x;md.x(tip)];
    5959                md.y=[md.y;md.y(tip)];
    60                 md.numberofnodes=num;
     60                md.mesh.numberofvertices=num;
    6161               
    6262                %replace tip in elements
    … …  
    8383
    8484%Fill in rest of fields:
    85 md.numberofelements=length(md.elements);
    86 md.numberofnodes=length(md.x);
    87 md.z=zeros(md.numberofnodes,1);
     85md.mesh.numberofelements=length(md.elements);
     86md.mesh.numberofvertices=length(md.x);
     87md.z=zeros(md.mesh.numberofvertices,1);
    8888md.mesh.vertexonboundary=zeros(length(md.x),1); md.mesh.vertexonboundary(md.mesh.segments(:,1:2))=1;
    8989md.rifts.numrifts=length(md.rifts.riftstruct);
    90 md.flowequation.element_equation=3*ones(md.numberofelements,1);
    91 md.nodeonbed=ones(md.numberofnodes,1);
    92 md.nodeonsurface=ones(md.numberofnodes,1);
    93 md.elementonbed=ones(md.numberofelements,1);
    94 md.elementonsurface=ones(md.numberofelements,1);
     90md.flowequation.element_equation=3*ones(md.mesh.numberofelements,1);
     91md.nodeonbed=ones(md.mesh.numberofvertices,1);
     92md.nodeonsurface=ones(md.mesh.numberofvertices,1);
     93md.elementonbed=ones(md.mesh.numberofelements,1);
     94md.elementonsurface=ones(md.mesh.numberofelements,1);

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

    r9714 r9725  
    3131
    3232%Fill in rest of fields:
    33 md.numberofelements=length(md.elements);
    34 md.numberofnodes=length(md.x);
    35 md.z=zeros(md.numberofnodes,1);
     33md.mesh.numberofelements=length(md.elements);
     34md.mesh.numberofvertices=length(md.x);
     35md.z=zeros(md.mesh.numberofvertices,1);
    3636md.mesh.vertexonboundary=zeros(length(md.x),1); md.mesh.vertexonboundary(md.mesh.segments(:,1:2))=1;
    3737md.rifts.numrifts=length(md.rifts.riftstruct);
    38 md.flowequation.element_equation=3*ones(md.numberofelements,1);
    39 md.nodeonbed=ones(md.numberofnodes,1);
    40 md.nodeonsurface=ones(md.numberofnodes,1);
    41 md.elementonbed=ones(md.numberofelements,1);
    42 md.elementonsurface=ones(md.numberofelements,1);
     38md.flowequation.element_equation=3*ones(md.mesh.numberofelements,1);
     39md.nodeonbed=ones(md.mesh.numberofvertices,1);
     40md.nodeonsurface=ones(md.mesh.numberofvertices,1);
     41md.elementonbed=ones(md.mesh.numberofelements,1);
     42md.elementonsurface=ones(md.mesh.numberofelements,1);
    4343
    4444%get coordinates of rift tips

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

    r9719 r9725  
    2727
    2828%Check that mesh was not already run, and warn user:
    29 if md.numberofelements~=0,
     29if md.mesh.numberofelements~=0,
    3030        choice=input('This model already has a mesh. Are you sure you want to go ahead? (y/n)','s');
    3131        if ~strcmp(choice,'y')
    … …  
    6969
    7070%Fill in rest of fields:
    71 md.numberofelements=length(md.elements);
    72 md.numberofnodes=length(md.x);
    73 md.z=zeros(md.numberofnodes,1);
    74 md.mesh.vertexonboundary=zeros(md.numberofnodes,1); md.mesh.vertexonboundary(md.mesh.segments(:,1:2))=1;
    75 md.nodeonbed=ones(md.numberofnodes,1);
    76 md.nodeonsurface=ones(md.numberofnodes,1);
    77 md.elementonbed=ones(md.numberofelements,1);
    78 md.elementonsurface=ones(md.numberofelements,1);
     71md.mesh.numberofelements=length(md.elements);
     72md.mesh.numberofvertices=length(md.x);
     73md.z=zeros(md.mesh.numberofvertices,1);
     74md.mesh.vertexonboundary=zeros(md.mesh.numberofvertices,1); md.mesh.vertexonboundary(md.mesh.segments(:,1:2))=1;
     75md.nodeonbed=ones(md.mesh.numberofvertices,1);
     76md.nodeonsurface=ones(md.mesh.numberofvertices,1);
     77md.elementonbed=ones(md.mesh.numberofelements,1);
     78md.elementonsurface=ones(md.mesh.numberofelements,1);
    7979
    8080%Now, build the connectivity tables for this mesh.
    81 md.nodeconnectivity=NodeConnectivity(md.elements,md.numberofnodes);
     81md.nodeconnectivity=NodeConnectivity(md.elements,md.mesh.numberofvertices);
    8282md.elementconnectivity=ElementConnectivity(md.elements,md.nodeconnectivity);
    8383

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

    r9719 r9725  
    2121        x=md.x2d;
    2222        y=md.y2d;
    23         vx=project2d(md,md.initialization.vx,md.numlayers);
    24         vy=project2d(md,md.initialization.vy,md.numlayers);
    25         vx_obs=project2d(md,md.inversion.vx_obs,md.numlayers);
    26         vy_obs=project2d(md,md.inversion.vy_obs,md.numlayers);
     23        vx=project2d(md,md.initialization.vx,md.mesh.numberoflayers);
     24        vy=project2d(md,md.initialization.vy,md.mesh.numberoflayers);
     25        vx_obs=project2d(md,md.inversion.vx_obs,md.mesh.numberoflayers);
     26        vy_obs=project2d(md,md.inversion.vy_obs,md.mesh.numberoflayers);
    2727end
    2828

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

    r9719 r9725  
    2222%2D or 3D?
    2323if md.mesh.dimension==3,
    24         numberofelements=md.numberofelements2d; %this will be forgotten when we get out.
     24        numberofelements=md.mesh.numberofelements2d; %this will be forgotten when we get out.
    2525        flags=project2d(md,flags,1);
    2626else
    27         numberofelements=md.numberofelements;
     27        numberofelements=md.mesh.numberofelements;
    2828end
    2929

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

    r9714 r9725  
    1515VdotN=Vx.*Nx+Vy.*Ny;
    1616
    17 flag=zeros(md.numberofnodes,1);
     17flag=zeros(md.mesh.numberofvertices,1);
    1818flag(A(find(VdotN>0)))=1;

  • issm/trunk/src/m/model/parameterization/parametercontrolB.m

    r9681 r9725  
    2424
    2525%weights
    26 weights=getfieldvalue(options,'weights',ones(md.numberofnodes,1));
    27 if (length(weights)~=md.numberofnodes)
    28         md.inversion.cost_functions_coefficients=ones(md.numberofnodes,1);
     26weights=getfieldvalue(options,'weights',ones(md.mesh.numberofvertices,1));
     27if (length(weights)~=md.mesh.numberofvertices)
     28        md.inversion.cost_functions_coefficients=ones(md.mesh.numberofvertices,1);
    2929else
    3030        md.inversion.cost_functions_coefficients=weights;
    … …  
    4141
    4242%cm_min
    43 cm_min=getfieldvalue(options,'cm_min',paterson(273.15+5)*ones(md.numberofnodes,1));
     43cm_min=getfieldvalue(options,'cm_min',paterson(273.15+5)*ones(md.mesh.numberofvertices,1));
    4444if (length(cm_min)==1)
    45         md.inversion.min_parameters=cm_min*ones(md.numberofnodes,1);
    46 elseif (length(cm_min)==md.numberofnodes)
     45        md.inversion.min_parameters=cm_min*ones(md.mesh.numberofvertices,1);
     46elseif (length(cm_min)==md.mesh.numberofvertices)
    4747        md.inversion.min_parameters=cm_min;
    4848else
    … …  
    5151
    5252%cm_max
    53 cm_max=getfieldvalue(options,'cm_max',paterson(273.15-70)*ones(md.numberofnodes,1));
     53cm_max=getfieldvalue(options,'cm_max',paterson(273.15-70)*ones(md.mesh.numberofvertices,1));
    5454if (length(cm_max)==1)
    55         md.inversion.max_parameters=cm_max*ones(md.numberofnodes,1);
    56 elseif (length(cm_max)==md.numberofnodes)
     55        md.inversion.max_parameters=cm_max*ones(md.mesh.numberofvertices,1);
     56elseif (length(cm_max)==md.mesh.numberofvertices)
    5757        md.inversion.max_parameters=cm_max;
    5858else

  • issm/trunk/src/m/model/parameterization/parametercontroldrag.m

    r9681 r9725  
    2424
    2525%weights
    26 weights=getfieldvalue(options,'weights',ones(md.numberofnodes,1));
    27 if (length(weights)~=md.numberofnodes)
    28         md.inversion.cost_functions_coefficients=ones(md.numberofnodes,1);
     26weights=getfieldvalue(options,'weights',ones(md.mesh.numberofvertices,1));
     27if (length(weights)~=md.mesh.numberofvertices)
     28        md.inversion.cost_functions_coefficients=ones(md.mesh.numberofvertices,1);
    2929else
    3030        md.inversion.cost_functions_coefficients=weights;
    … …  
    4040
    4141%cm_min
    42 cm_min=getfieldvalue(options,'cm_min',1*ones(md.numberofnodes,1));
     42cm_min=getfieldvalue(options,'cm_min',1*ones(md.mesh.numberofvertices,1));
    4343if (length(cm_min)==1)
    44         md.inversion.min_parameters=cm_min*ones(md.numberofnodes,1);
    45 elseif (length(cm_min)==md.numberofnodes)
     44        md.inversion.min_parameters=cm_min*ones(md.mesh.numberofvertices,1);
     45elseif (length(cm_min)==md.mesh.numberofvertices)
    4646        md.inversion.min_parameters=cm_min;
    4747else
    … …  
    5050
    5151%cm_max
    52 cm_max=getfieldvalue(options,'cm_max',250*ones(md.numberofnodes,1));
     52cm_max=getfieldvalue(options,'cm_max',250*ones(md.mesh.numberofvertices,1));
    5353if (length(cm_max)==1)
    54         md.inversion.max_parameters=cm_max*ones(md.numberofnodes,1);
    55 elseif (length(cm_max)==md.numberofnodes)
     54        md.inversion.max_parameters=cm_max*ones(md.mesh.numberofvertices,1);
     55elseif (length(cm_max)==md.mesh.numberofvertices)
    5656        md.inversion.max_parameters=cm_max;
    5757else

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

    r9719 r9725  
    1919        md.x=md.x2d;
    2020        md.y=md.y2d;
    21         md.numberofnodes=md.numberofnodes2d;
    22         md.numberofelements=md.numberofelements2d;
     21        md.mesh.numberofvertices=md.mesh.numberofvertices2d;
     22        md.mesh.numberofelements=md.mesh.numberofelements2d;
    2323        md.vertex_weight=[];
    2424        md.nodeconnectivity=[];

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

    r9668 r9725  
    1212values=1;
    1313
    14 md.qmu.adjacency=sparse(indi,indj,values,md.numberofnodes,md.numberofnodes);
     14md.qmu.adjacency=sparse(indi,indj,values,md.mesh.numberofvertices,md.mesh.numberofvertices);
    1515md.qmu.adjacency=double([md.qmu.adjacency | md.qmu.adjacency']);
    1616
    … …  
    1919
    2020%get node connectivity
    21 md.nodeconnectivity=NodeConnectivity(md.elements,md.numberofnodes);
     21md.nodeconnectivity=NodeConnectivity(md.elements,md.mesh.numberofvertices);
    2222
    2323connectivity=md.nodeconnectivity(:,1:end-1);

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

    r9719 r9725  
    3737        md.x=md.x2d;
    3838        md.y=md.y2d;
    39         md.numberofnodes=md.numberofnodes2d;
    40         md.numberofelements=md.numberofelements2d;
     39        md.mesh.numberofvertices=md.mesh.numberofvertices2d;
     40        md.mesh.numberofelements=md.mesh.numberofelements2d;
    4141        md.qmu.vertex_weight=[];
    4242        md.nodeconnectivity=[];
    … …  
    8585elseif strcmpi(package,'linear'),
    8686
    87         part=1:1:md.numberofnodes;
     87        part=1:1:md.mesh.numberofvertices;
    8888
    8989elseif strcmpi(package,'metis'),

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

    r8472 r9725  
    1111%process data and model
    1212[x y z elements is2d isplanet]=processmesh(md,[],options);
    13 [elementnumbers datatype]=processdata(md,[1:md.numberofelements]',options);
     13[elementnumbers datatype]=processdata(md,[1:md.mesh.numberofelements]',options);
    1414
    1515%plot

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

    r8472 r9725  
    1212%process data and model
    1313[x y z elements is2d isplanet]=processmesh(md,[],options);
    14 [elementnumbers datatype]=processdata(md,[1:md.numberofelements]',options);
     14[elementnumbers datatype]=processdata(md,[1:md.mesh.numberofelements]',options);
    1515
    1616%plot

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

    r8472 r9725  
    99%process data and model
    1010[x y z elements is2d isplanet]=processmesh(md,[],options);
    11 [nodenumbers datatype]=processdata(md,[1:md.numberofnodes]',options);
     11[nodenumbers datatype]=processdata(md,[1:md.mesh.numberofvertices]',options);
    1212
    1313%plot

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

    r8472 r9725  
    99%process data and model
    1010[x y z elements is2d isplanet]=processmesh(md,[],options);
    11 [nodenumbers datatype]=processdata(md,[1:md.numberofnodes]',options);
     11[nodenumbers datatype]=processdata(md,[1:md.mesh.numberofvertices]',options);
    1212
    1313%plot

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

    r9620 r9725  
    1111if strcmpi(data,'none'),
    1212        radaronly=1;
    13         data=NaN*ones(md.numberofnodes,1);
     13        data=NaN*ones(md.mesh.numberofvertices,1);
    1414        datatype=1;
    1515else

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

    r9714 r9725  
    2424
    2525%first, build a vector of fractions, over all nodes.
    26 fractions=zeros(md.numberofnodes,1);
     26fractions=zeros(md.mesh.numberofvertices,1);
    2727
    2828%complete the tips.

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

    r9714 r9725  
    88
    99%some checks
    10 if (length(md.initialization.vx)~=md.numberofnodes | length(md.initialization.vy)~=md.numberofnodes),
     10if (length(md.initialization.vx)~=md.mesh.numberofvertices | length(md.initialization.vy)~=md.mesh.numberofvertices),
    1111        error('plot_riftvel error message: vx and vy do not have the right size'),
    1212end
    … …  
    2121
    2222%set as NaN all velocities not on rifts
    23 u=NaN*ones(md.numberofnodes,1);
    24 v=NaN*ones(md.numberofnodes,1);
     23u=NaN*ones(md.mesh.numberofvertices,1);
     24v=NaN*ones(md.mesh.numberofvertices,1);
    2525for i=1:md.rifts.numrifts,
    2626        penaltypairs=md.rifts.riftstruct(i).penaltypairs(:,[1 2]);

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

    r9714 r9725  
    88
    99%some checks
    10 if (length(md.initialization.vx)~=md.numberofnodes | length(md.initialization.vy)~=md.numberofnodes),
     10if (length(md.initialization.vx)~=md.mesh.numberofvertices | length(md.initialization.vy)~=md.mesh.numberofvertices),
    1111        error('plot_riftvel error message: vx and vy do not have the right size'),
    1212end
    … …  
    1717
    1818%set as NaN all velocities not on rifts
    19 u=NaN*ones(md.numberofnodes,1);
    20 v=NaN*ones(md.numberofnodes,1);
     19u=NaN*ones(md.mesh.numberofvertices,1);
     20v=NaN*ones(md.mesh.numberofvertices,1);
    2121for i=1:md.rifts.numrifts,
    2222        penaltypairs=md.rifts.riftstruct(i).penaltypairs(:,[1 2]);

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

    r9719 r9725  
    5252                        resolution=getfieldvalue(options,'resolution');
    5353                else %Default resolution
    54                         resolution=[1000 10*md.numlayers];
     54                        resolution=[1000 10*md.mesh.numberoflayers];
    5555                        disp(['plot_section warning: no resolution specified, use default resolution: [horizontal_resolution vertical_resolution]=[' num2str(resolution)  ']']);
    5656                end

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

    r9719 r9725  
    5858
    5959        %check length
    60         if datasize(1)~=md.numberofnodes & datasize(1)~=md.numberofelements & datasize(1)~=md.numberofnodes*6 & (md.mesh.dimension==3 & ~(datasize(1)==md.numberofelements2d | datasize(1)==md.numberofnodes2d))
     60        if datasize(1)~=md.mesh.numberofvertices & datasize(1)~=md.mesh.numberofelements & datasize(1)~=md.mesh.numberofvertices*6 & (md.mesh.dimension==3 & ~(datasize(1)==md.mesh.numberofelements2d | datasize(1)==md.mesh.numberofvertices2d))
    6161                error('plotmodel error message: data not supported yet');
    6262        end
    … …  
    7979
    8080        %treat the case datasize(1)=6*nodes
    81         if datasize(1)==6*md.numberofnodes
     81        if datasize(1)==6*md.mesh.numberofvertices
    8282                %keep the only norm of data
    83                 data1=data(1:6:md.numberofnodes*6,:);
    84                 data2=data(2:6:md.numberofnodes*6,:);
     83                data1=data(1:6:md.mesh.numberofvertices*6,:);
     84                data2=data(2:6:md.mesh.numberofvertices*6,:);
    8585                data=sqrt(data1.^2+data2.^2);
    86                 datasize(1)=md.numberofnodes;
     86                datasize(1)=md.mesh.numberofvertices;
    8787                %---> go to node data
    8888        end
    8989
    9090        %treat the case datasize(1)=nodes2d
    91         if (md.mesh.dimension==3 & datasize(1)==md.numberofnodes2d),
     91        if (md.mesh.dimension==3 & datasize(1)==md.mesh.numberofvertices2d),
    9292                data=project3d(md,data,'node');
    93                 datasize(1)=md.numberofnodes;
     93                datasize(1)=md.mesh.numberofvertices;
    9494                %---> go to node data
    9595        end
    9696
    9797        %treat the case datasize(1)=nodes2d
    98         if (md.mesh.dimension==3 & datasize(1)==md.numberofelements2d),
     98        if (md.mesh.dimension==3 & datasize(1)==md.mesh.numberofelements2d),
    9999                data=project3d(md,data,'element');
    100                 datasize(1)=md.numberofelements;
     100                datasize(1)=md.mesh.numberofelements;
    101101                %---> go to node data
    102102        end
    … …  
    105105        if exist(options,'smooth')
    106106                data=averaging(md,data,getfieldvalue(options,'smooth'));
    107                 datasize(1)=md.numberofnodes;
     107                datasize(1)=md.mesh.numberofvertices;
    108108                %---> go to node data
    109109        end
    … …  
    111111
    112112%element data
    113 if (datasize(1)==md.numberofelements & datasize(2)==1),
     113if (datasize(1)==md.mesh.numberofelements & datasize(2)==1),
    114114
    115115        %Initialize datatype if non patch
    … …  
    122122                flags=getfieldvalue(options,'mask');
    123123                pos=find(~flags);
    124                 if length(flags)==md.numberofnodes,
     124                if length(flags)==md.mesh.numberofvertices,
    125125                        [pos2 dummy]=find(ismember(md.elements,pos));
    126126                        data(pos2,:)=NaN;
    127                 elseif length(flags)==md.numberofelements
     127                elseif length(flags)==md.mesh.numberofelements
    128128                        data(pos,:)=NaN;
    129129                else
    130                         disp('plotmodel warning: mask length not supported yet (supported length are md.numberofnodes and md.numberofelements');
     130                        disp('plotmodel warning: mask length not supported yet (supported length are md.mesh.numberofvertices and md.mesh.numberofelements');
    131131                end
    132132        end
    … …  
    145145
    146146%node data
    147 if (datasize(1)==md.numberofnodes & datasize(2)==1),
     147if (datasize(1)==md.mesh.numberofvertices & datasize(2)==1),
    148148        datatype=2;
    149149
    … …  
    152152                flags=getfieldvalue(options,'mask');
    153153                pos=find(~flags);
    154                 if length(flags)==md.numberofnodes,
     154                if length(flags)==md.mesh.numberofvertices,
    155155                        data(pos,:)=NaN;
    156                 elseif length(flags)==md.numberofelements
     156                elseif length(flags)==md.mesh.numberofelements
    157157                        data(md.elements(pos,:),:)=NaN;
    158158                else
    159                         disp('plotmodel warning: mask length not supported yet (supported length are md.numberofnodes and md.numberofelements');
     159                        disp('plotmodel warning: mask length not supported yet (supported length are md.mesh.numberofvertices and md.mesh.numberofelements');
    160160                end
    161161        end

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

    r9719 r9725  
    88
    99%some checks
    10 if md.numberofnodes==md.numberofelements
     10if md.mesh.numberofvertices==md.mesh.numberofelements
    1111        error('plot error message: the number of elements is the same as the number of nodes! cannot plot anything with model/plot, use matlab/plot instead')
    1212end
    … …  
    6767        %Process Patch
    6868        if (md.mesh.dimension==2),
    69                 elements=transpose(reshape(1:3*md.numberofelements,3,md.numberofelements));
    70                 x=transpose(reshape(md.x(data.index)',1,3*md.numberofelements));
    71                 y=transpose(reshape(md.y(data.index)',1,3*md.numberofelements));
    72                 z=zeros(3*md.numberofelements,1);
     69                elements=transpose(reshape(1:3*md.mesh.numberofelements,3,md.mesh.numberofelements));
     70                x=transpose(reshape(md.x(data.index)',1,3*md.mesh.numberofelements));
     71                y=transpose(reshape(md.y(data.index)',1,3*md.mesh.numberofelements));
     72                z=zeros(3*md.mesh.numberofelements,1);
    7373                is2d=1;
    7474        else
    75                 elements=transpose(reshape(1:6*md.numberofelements,6,md.numberofelements));
    76                 x=transpose(reshape(md.x(data.index)',1,6*md.numberofelements));
    77                 y=transpose(reshape(md.y(data.index)',1,6*md.numberofelements));
    78                 z=transpose(reshape(md.z(data.index)',1,6*md.numberofelements));
     75                elements=transpose(reshape(1:6*md.mesh.numberofelements,6,md.mesh.numberofelements));
     76                x=transpose(reshape(md.x(data.index)',1,6*md.mesh.numberofelements));
     77                y=transpose(reshape(md.y(data.index)',1,6*md.mesh.numberofelements));
     78                z=transpose(reshape(md.z(data.index)',1,6*md.mesh.numberofelements));
    7979                is2d=0;
    8080        end

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

    r9556 r9725  
    1111if ~ismember(solution_type,[DiagnosticSolutionEnum,PrognosticSolutionEnum,ThermalSolutionEnum,...
    1212                SteadystateSolutionEnum,TransientSolutionEnum,EnthalpySolutionEnum,...
    13                 BalancethicknessSolutionEnum,BedSlopeSolutionEnum,SurfaceSlopeSolutionEnum,GroundinglineMigration2DSolutionEnum,HydrologySolutionEnum,FlaimSolutionEnum]),
     13                BalancethicknessSolutionEnum,BedSlopeSolutionEnum,SurfaceSlopeSolutionEnum,GroundinglineMigration2dSolutionEnum,HydrologySolutionEnum,FlaimSolutionEnum]),
    1414        error(['process_solve_options error message: solution_type ' EnumToString(solution_type) ' not supported yet!']);
    1515end

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

    r9603 r9725  
    2020end
    2121
    22 if (md3d.dim~=3),
     22if (md3d.mesh.dimension~=3),
    2323        error('wrong model type ... should be ''3d''');
    2424end
    2525
    26 if ((layer<1) | (layer>md3d.numlayers)),
     26if ((layer<1) | (layer>md3d.mesh.numberoflayers)),
    2727        error(['layer must be between 1 and ' num2str(md3d.numlayers)]);
    2828end
    2929
    30 if size(value,1)==md3d.numberofnodes,
    31         projection_value=value((layer-1)*md3d.numberofnodes2d+1:layer*md3d.numberofnodes2d,:);
    32 elseif size(value,1)==md3d.numberofnodes+1,
    33         projection_value=[value((layer-1)*md3d.numberofnodes2d+1:layer*md3d.numberofnodes2d,:); value(end,:)];
     30if size(value,1)==md3d.mesh.numberofnodes,
     31        projection_value=value((layer-1)*md3d.mesh.numberofvertices2d+1:layer*md3d.mesh.numberofvertices2d,:);
     32elseif size(value,1)==md3d.mesh.numberofnodes+1,
     33        projection_value=[value((layer-1)*md3d.mesh.numberofvertices2d+1:layer*md3d.mesh.numberofvertices2d,:); value(end,:)];
    3434else
    35         projection_value=value((layer-1)*md3d.numberofelements2d+1:layer*md3d.numberofelements2d,:);
     35        projection_value=value((layer-1)*md3d.mesh.numberofelements2d+1:layer*md3d.mesh.numberofelements2d,:);
    3636end

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

    r9719 r9725  
    33%
    44%   vertically project a vector from 2d mesh (split in noncoll and coll areas) into a 3d mesh.
    5 %   This vector can be a node vector of size (md.numberofnodes2d,N/A) or an
    6 %   element vector of size (md.numberofelements2d,N/A).
     5%   This vector can be a node vector of size (md.mesh.numberofvertices2d,N/A) or an
     6%   element vector of size (md.mesh.numberofelements2d,N/A).
    77%   arguments:
    88%      'vector': 2d vector
    … …  
    3939
    4040        %Initialize 3d vector
    41         if size(vector2d,1)==md.numberofnodes2d
    42                 projected_vector=paddingvalue*ones(md.numberofnodes,  size(vector2d,2));
    43         elseif size(vector2d,1)==md.numberofnodes2d+1
    44                 projected_vector=paddingvalue*ones(md.numberofnodes+1,size(vector2d,2));
     41        if size(vector2d,1)==md.mesh.numberofvertices2d
     42                projected_vector=paddingvalue*ones(md.mesh.numberofvertices,  size(vector2d,2));
     43        elseif size(vector2d,1)==md.mesh.numberofvertices2d+1
     44                projected_vector=paddingvalue*ones(md.mesh.numberofvertices+1,size(vector2d,2));
    4545                projected_vector(end,:)=vector2d(end,:);
    4646                vector2d=vector2d(1:end-1,:);
    … …  
    5151        %Fill in
    5252        if layer==0,
    53                 for i=1:md.numlayers,
    54                         projected_vector(((i-1)*md.numberofnodes2d+1):(i*md.numberofnodes2d),:)=vector2d;
     53                for i=1:md.mesh.numberoflayers,
     54                        projected_vector(((i-1)*md.mesh.numberofvertices2d+1):(i*md.mesh.numberofvertices2d),:)=vector2d;
    5555                end
    5656        else
    57                 projected_vector(((layer-1)*md.numberofnodes2d+1):(layer*md.numberofnodes2d),:)=vector2d;
     57                projected_vector(((layer-1)*md.mesh.numberofvertices2d+1):(layer*md.mesh.numberofvertices2d),:)=vector2d;
    5858        end
    5959elseif strcmpi(type,'element'),
    6060
    6161        %Initialize 3d vector
    62         if size(vector2d,1)==md.numberofelements2d
    63                 projected_vector=paddingvalue*ones(md.numberofelements,  size(vector2d,2));
    64         elseif size(vector2d,1)==md.numberofelements2d+1
    65                 projected_vector=paddingvalue*ones(md.numberofelements+1,size(vector2d,2));
     62        if size(vector2d,1)==md.mesh.numberofelements2d
     63                projected_vector=paddingvalue*ones(md.mesh.numberofelements,  size(vector2d,2));
     64        elseif size(vector2d,1)==md.mesh.numberofelements2d+1
     65                projected_vector=paddingvalue*ones(md.mesh.numberofelements+1,size(vector2d,2));
    6666                projected_vector(end,:)=vector2d(end,:);
    6767                vector2d=vector2d(1:end-1,:);
    … …  
    7171
    7272        if layer==0,
    73                 for i=1:(md.numlayers-1),
    74                         projected_vector( ((i-1)*md.numberofelements2d+1):(i*md.numberofelements2d),:)=vector2d;
     73                for i=1:(md.mesh.numberoflayers-1),
     74                        projected_vector( ((i-1)*md.mesh.numberofelements2d+1):(i*md.mesh.numberofelements2d),:)=vector2d;
    7575                end
    7676
    7777        else
    78                 projected_vector( ((layer-1)*md.numberofelements2d+1):(layer*md.numberofelements2d),:)=vector2d;
     78                projected_vector( ((layer-1)*md.mesh.numberofelements2d+1):(layer*md.mesh.numberofelements2d),:)=vector2d;
    7979        end
    8080else

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

    r9719 r9725  
    6868
    6969%add in model who is who
    70 md.flowequation.element_equation=zeros(md.numberofelements,1);
     70md.flowequation.element_equation=zeros(md.mesh.numberofelements,1);
    7171
    7272%1: Hutter elements
    73 nodeonhutter=zeros(md.numberofnodes,1);
     73nodeonhutter=zeros(md.mesh.numberofvertices,1);
    7474nodeonhutter(md.elements(find(hutterflag),:))=1;
    7575md.flowequation.element_equation(find(hutterflag))=1;
    7676
    7777%2: MacAyeal elements
    78 nodeonmacayeal=zeros(md.numberofnodes,1);
     78nodeonmacayeal=zeros(md.mesh.numberofvertices,1);
    7979nodeonmacayeal(md.elements(find(macayealflag),:))=1;
    8080md.flowequation.bordermacayeal=nodeonmacayeal;
    … …  
    8282
    8383%3: Pattyn elements
    84 nodeonpattyn=zeros(md.numberofnodes,1);
     84nodeonpattyn=zeros(md.mesh.numberofvertices,1);
    8585nodeonpattyn(md.elements(find(pattynflag),:))=1;
    8686md.flowequation.borderpattyn=nodeonpattyn;
    … …  
    9090%First modify stokesflag to get rid of elements contrained everywhere (spc + border with pattyn or macayeal)
    9191if any(stokesflag),
    92         nodeonstokes=zeros(md.numberofnodes,1);
     92        nodeonstokes=zeros(md.mesh.numberofvertices,1);
    9393        nodeonstokes(md.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
    … …  
    9696        stokesflag(find(fullspcelems))=0;
    9797end
    98 nodeonstokes=zeros(md.numberofnodes,1);
     98nodeonstokes=zeros(md.mesh.numberofvertices,1);
    9999nodeonstokes(md.elements(find(stokesflag),:))=1;
    100100md.flowequation.borderstokes=nodeonstokes;
    … …  
    121121%Now take care of the coupling between MacAyeal and Pattyn
    122122md.diagnostic.vertex_pairing=[];
    123 nodeonmacayealpattyn=zeros(md.numberofnodes,1);
    124 nodeonpattynstokes=zeros(md.numberofnodes,1);
    125 nodeonmacayealstokes=zeros(md.numberofnodes,1);
     123nodeonmacayealpattyn=zeros(md.mesh.numberofvertices,1);
     124nodeonpattynstokes=zeros(md.mesh.numberofvertices,1);
     125nodeonmacayealstokes=zeros(md.mesh.numberofvertices,1);
    126126if strcmpi(coupling_method,'penalties'),
    127127        %Create the border nodes between Pattyn and MacAyeal and extrude them
    128         numnodes2d=md.numberofnodes2d;
    129         numlayers=md.numlayers;
     128        numnodes2d=md.mesh.numberofvertices2d;
     129        numlayers=md.mesh.numberoflayers;
    130130        bordernodes2d=find(nodeonpattyn(1:numnodes2d) & nodeonmacayeal(1:numnodes2d)); %Nodes connected to two different types of elements
    131131
    … …  
    134134                penalties=[];
    135135                for     i=1:numlayers-1,
    136                         penalties=[penalties; [bordernodes2d bordernodes2d+md.numberofnodes2d*(i)]];
     136                        penalties=[penalties; [bordernodes2d bordernodes2d+md.mesh.numberofvertices2d*(i)]];
    137137                end
    138138                md.diagnostic.vertex_pairing=penalties;
    … …  
    147147                commonelements(find(pattynflag))=0; %only one layer: the elements previously in macayeal
    148148                macayealflag(find(commonelements))=0; %these elements are now macayealpattynelements
    149                 macayealpattynflag=zeros(md.numberofelements,1);
     149                macayealpattynflag=zeros(md.mesh.numberofelements,1);
    150150                macayealpattynflag(find(commonelements))=1;
    151                 nodeonmacayeal=zeros(md.numberofnodes,1);
     151                nodeonmacayeal=zeros(md.mesh.numberofvertices,1);
    152152                nodeonmacayeal(md.elements(find(macayealflag),:))=1;
    153153                md.flowequation.bordermacayeal=nodeonmacayeal;
    … …  
    166166                commonelements(find(pattynflag))=0; %only one layer: the elements previously in macayeal
    167167                stokesflag(find(commonelements))=0; %these elements are now macayealpattynelements
    168                 pattynstokesflag=zeros(md.numberofelements,1);
     168                pattynstokesflag=zeros(md.mesh.numberofelements,1);
    169169                pattynstokesflag(find(commonelements))=1;
    170                 nodeonstokes=zeros(md.numberofnodes,1);
     170                nodeonstokes=zeros(md.mesh.numberofvertices,1);
    171171                nodeonstokes(md.elements(find(stokesflag),:))=1;
    172172                md.flowequation.borderstokes=nodeonstokes;
    … …  
    176176
    177177                %Now recreate nodeonpattynstokes
    178                 nodeonpattynstokes=zeros(md.numberofnodes,1);
     178                nodeonpattynstokes=zeros(md.mesh.numberofvertices,1);
    179179                nodeonpattynstokes(md.elements(find(pattynstokesflag),:))=1;
    180180        elseif any(stokesflag) & any(macayealflag),
    … …  
    186186                commonelements(find(macayealflag))=0; %only one layer: the elements previously in macayeal
    187187                stokesflag(find(commonelements))=0; %these elements are now macayealmacayealelements
    188                 macayealstokesflag=zeros(md.numberofelements,1);
     188                macayealstokesflag=zeros(md.mesh.numberofelements,1);
    189189                macayealstokesflag(find(commonelements))=1;
    190                 nodeonstokes=zeros(md.numberofnodes,1);
     190                nodeonstokes=zeros(md.mesh.numberofvertices,1);
    191191                nodeonstokes(md.elements(find(stokesflag),:))=1;
    192192                md.flowequation.borderstokes=nodeonstokes;
    … …  
    196196
    197197                %Now recreate nodeonmacayealstokes
    198                 nodeonmacayealstokes=zeros(md.numberofnodes,1);
     198                nodeonmacayealstokes=zeros(md.mesh.numberofvertices,1);
    199199                nodeonmacayealstokes(md.elements(find(macayealstokesflag),:))=1;
    200200        elseif any(stokesflag) & any(hutterflag),
    … …  
    204204
    205205%Create vertices_type
    206 md.flowequation.vertex_equation=zeros(md.numberofnodes,1);
     206md.flowequation.vertex_equation=zeros(md.mesh.numberofvertices,1);
    207207pos=find(nodeonhutter);
    208208md.flowequation.vertex_equation(pos)=1;

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

    r9641 r9725  
    3535
    3636%the order here is important. we choose vertexongroundedice as default on the grounding line.
    37 vertexonfloatingice=zeros(md.numberofnodes,1);
    38 vertexongroundedice=zeros(md.numberofnodes,1);
     37vertexonfloatingice=zeros(md.mesh.numberofvertices,1);
     38vertexongroundedice=zeros(md.mesh.numberofvertices,1);
    3939vertexongroundedice(md.elements(find(elementongroundedice),:))=1;
    4040vertexonfloatingice(find(~vertexongroundedice))=1;
    … …  
    4646md.mask.elementongroundedice=elementongroundedice;
    4747md.mask.vertexongroundedice=vertexongroundedice;
    48 md.mask.vertexonwater=zeros(md.numberofnodes,1);
    49 md.mask.elementonwater=zeros(md.numberofelements,1);
     48md.mask.vertexonwater=zeros(md.mesh.numberofvertices,1);
     49md.mask.elementonwater=zeros(md.mesh.numberofelements,1);

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

    r9714 r9725  
    1717        [vertexonland,elementonland]=ContourToMesh(elements,x,y,landname,'element and node',2);
    1818elseif isfloat(landname),
    19         if size(landname,1)~=md.numberofelements,
     19        if size(landname,1)~=md.mesh.numberofelements,
    2020                error('Landname for area must be of same size as number of elements in model');
    2121        end
    2222        elementonland=landname;
    23         vertexonland=zeros(md.numberofnodes,1);
     23        vertexonland=zeros(md.mesh.numberofvertices,1);
    2424        vertexonland(md.elements(find(elementonland),:))=1;
    2525else
    … …  
    2828
    2929%Now, build the connectivity tables for this mesh.
    30 if size(md.nodeconnectivity,1)~=md.numberofnodes,
    31         md.nodeconnectivity=NodeConnectivity(md.elements,md.numberofnodes);
     30if size(md.nodeconnectivity,1)~=md.mesh.numberofvertices,
     31        md.nodeconnectivity=NodeConnectivity(md.elements,md.mesh.numberofvertices);
    3232end
    33 if size(md.elementconnectivity,1)~=md.numberofelements,
     33if size(md.elementconnectivity,1)~=md.mesh.numberofelements,
    3434        md.elementconnectivity=ElementConnectivity(md.elements,md.nodeconnectivity);
    3535end
    … …  
    7575%Because groundedice nodes and elements can be included into an floatingice, we need to update. Remember, all the previous
    7676%arrays come from domain outlines that can intersect one another:
    77 vertexonfloatingice=zeros(md.numberofnodes,1);
    78 vertexongroundedice=zeros(md.numberofnodes,1);
     77vertexonfloatingice=zeros(md.mesh.numberofvertices,1);
     78vertexongroundedice=zeros(md.mesh.numberofvertices,1);
    7979elementonfloatingice=double((elementonfloatingice & ~elementongroundedice));
    8080elementongroundedice=double(~elementonfloatingice);

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

    r9719 r9725  
    77%load some variables (it is much faster if the variab;es are loaded from md once for all)
    88if (md.mesh.dimension==2),
    9         numberofelements=md.numberofelements;
    10         numberofnodes=md.numberofnodes;
     9        numberofelements=md.mesh.numberofelements;
     10        numberofnodes=md.mesh.numberofvertices;
    1111        index=md.elements;
    1212        x=md.x; y=md.y;
    1313else
    14         numberofelements=md.numberofelements2d;
    15         numberofnodes=md.numberofnodes2d;
     14        numberofelements=md.mesh.numberofelements2d;
     15        numberofnodes=md.mesh.numberofvertices2d;
    1616        index=md.elements2d;
    1717        x=md.x2d; y=md.y2d;

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

    r9650 r9725  
    1515%                - BedSlopeSolutionEnum
    1616%                - SurfaceSlopeSolutionEnum
    17 %                - GroundinglineMigration2DSolutionEnum
     17%                - GroundinglineMigration2dSolutionEnum
    1818%                - HydrologySolutionEnum
    1919%                - FlaimSolutionEnum

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

    r9691 r9725  
    99%      dhdt=thicknessevolution(md)
    1010
    11 if (length(md.initialization.vx)~=md.numberofnodes)|(length(md.initialization.vy)~=md.numberofnodes)
    12         error(['thicknessevolution error message: vx and vy should have a length of ' num2str(md.numberofnodes)])
     11if (length(md.initialization.vx)~=md.mesh.numberofvertices)|(length(md.initialization.vy)~=md.mesh.numberofvertices)
     12        error(['thicknessevolution error message: vx and vy should have a length of ' num2str(md.mesh.numberofvertices)])
    1313end
    1414

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

    r9719 r9725  
    2626                        md.initialization.vz=PatchToVec(md.results.DiagnosticSolution.Vz);
    2727                else
    28                         md.initialization.vz=zeros(md.numberofnodes,1);
     28                        md.initialization.vz=zeros(md.mesh.numberofvertices,1);
    2929                end
    3030        end

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

    r9719 r9725  
    9494md.phi=atan2(y,x);
    9595
    96 md.numberofnodes=length(md.x);
    97 md.numberofelements=size(md.elements,1);
     96md.mesh.numberofvertices=length(md.x);
     97md.mesh.numberofelements=size(md.elements,1);
    9898
    9999md.mesh.dimension=3;

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

    r9719 r9725  
    1515md.phi=atan2(md.y,md.x);
    1616
    17 md.numberofnodes=length(md.x);
    18 md.numberofelements=size(md.elements,1);
     17md.mesh.numberofvertices=length(md.x);
     18md.mesh.numberofelements=size(md.elements,1);
    1919
    2020md.mesh.dimension=3;

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

    r9650 r9725  
    5151
    5252%weight importancefactors by area
    53 %if numel(factors)==md.numberofnodes,
     53%if numel(factors)==md.mesh.numberofvertices,
    5454%       %get areas for each vertex.
    5555%       aire=GetAreas(md.elements,md.x,md.y);
    5656%       num_elements_by_node=md.nodeconnectivity(:,end);
    57 %       grid_aire=zeros(md.numberofnodes,1);
    58 %       for i=1:md.numberofnodes,
     57%       grid_aire=zeros(md.mesh.numberofvertices,1);
     58%       for i=1:md.mesh.numberofvertices,
    5959%               for j=1:num_elements_by_node(i),
    6060%                       grid_aire(i)=grid_aire(i)+aire(md.nodeconnectivity(i,j));

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

    r9571 r9725  
    4949                analyses=[FlaimAnalysisEnum];
    5050
    51         case GroundinglineMigration2DSolutionEnum,
     51        case GroundinglineMigration2dSolutionEnum,
    5252                numanalyses=0;
    5353                analyses=[];

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

    r9594 r9725  
    1717        case TransientSolutionEnum,                solutioncore='transient_core';
    1818        case FlaimSolutionEnum,                    solutioncore='flaim_core';
    19         case GroundinglineMigration2DSolutionEnum, solutioncore='DUMMYDUMMY'; %not working in serial mode
     19        case GroundinglineMigration2dSolutionEnum, solutioncore='DUMMYDUMMY'; %not working in serial mode
    2020        case HydrologySolutionEnum,                solutioncore='DUMMYDUMMY'; %not working in serial mode
    2121        otherwise error('%s%s%s',' solution type: ',EnumToString(solutiontype),' not supported yet!');

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

    r9681 r9725  
    77        %recover parameters common to all solutions
    88        isstokes=femmodel.parameters.FlowequationIsstokes;
    9         dim=femmodel.parameters.Dim;
     9        dim=femmodel.parameters.MeshDimension;
    1010        control_analysis=femmodel.parameters.InversionIscontrol;
    1111        solution_type=femmodel.parameters.SolutionType;

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

    r9681 r9725  
    66
    77        %recover parameters common to all solutions
    8         dim=femmodel.parameters.Dim;
     8        dim=femmodel.parameters.MeshDimension;
    99        control_analysis=femmodel.parameters.InversionIscontrol;
    1010        solution_type=femmodel.parameters.SolutionType;

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

    r9681 r9725  
    77
    88        %Recover some parameters:
    9         dim=femmodel.parameters.Dim;
     9        dim=femmodel.parameters.MeshDimension;
    1010        control_analysis=femmodel.parameters.InversionIscontrol;
    1111        solution_type=femmodel.parameters.SolutionType;

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

    r9681 r9725  
    1717        eps_cm=femmodel.parameters.InversionCostFunctionThreshold;
    1818        gradient_only=femmodel.parameters.InversionGradientOnly;
    19         dim=femmodel.parameters.Dim;
     19        dim=femmodel.parameters.MeshDimension;
    2020        isstokes=femmodel.parameters.FlowequationIsstokes;
    2121

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

    r9681 r9725  
    1111
    1212        %recover parameters common to all solutions
    13         dim=femmodel.parameters.Dim;
     13        dim=femmodel.parameters.MeshDimension;
    1414        ishutter=femmodel.parameters.FlowequationIshutter;
    1515        ismacayealpattyn=femmodel.parameters.FlowequationIsmacayealpattyn;

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

    r9681 r9725  
    77
    88        %recover parameters common to all solutions
    9         dim=femmodel.parameters.Dim;
     9        dim=femmodel.parameters.MeshDimension;
    1010        control_analysis=femmodel.parameters.InversionIscontrol;
    1111        solution_type=femmodel.parameters.SolutionType;

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

    r9681 r9725  
    77
    88        %Recover some parameters:
    9         dim=femmodel.parameters.Dim;
     9        dim=femmodel.parameters.MeshDimension;
    1010        control_analysis=femmodel.parameters.InversionIscontrol;
    1111        solution_type=femmodel.parameters.SolutionType;

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

    r9702 r9725  
    66
    77        %recover parameters common to all solutions
    8         dim=femmodel.parameters.Dim;
     8        dim=femmodel.parameters.MeshDimension;
    99        ndt=femmodel.parameters.TimesteppingFinalTime;
    1010        dt=femmodel.parameters.TimesteppingTimeStep;

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

    r9719 r9725  
    99%node on Dirichlet
    1010pos=find(md.mesh.vertexonboundary);
    11 md.diagnostic.spcvx=NaN*ones(md.numberofnodes,1);
    12 md.diagnostic.spcvy=NaN*ones(md.numberofnodes,1);
    13 md.diagnostic.spcvz=NaN*ones(md.numberofnodes,1);
     11md.diagnostic.spcvx=NaN*ones(md.mesh.numberofvertices,1);
     12md.diagnostic.spcvy=NaN*ones(md.mesh.numberofvertices,1);
     13md.diagnostic.spcvz=NaN*ones(md.mesh.numberofvertices,1);
    1414md.diagnostic.spcvx(pos)=0;
    1515md.diagnostic.spcvy(pos)=0;
    1616md.diagnostic.spcvz(pos)=0;
    17 md.diagnostic.referential=NaN*ones(md.numberofnodes,6);
     17md.diagnostic.referential=NaN*ones(md.mesh.numberofvertices,6);
    1818
    1919%Dirichlet Values
    20 if (length(md.inversion.vx_obs)==md.numberofnodes & length(md.inversion.vy_obs)==md.numberofnodes)
     20if (length(md.inversion.vx_obs)==md.mesh.numberofvertices & length(md.inversion.vy_obs)==md.mesh.numberofvertices)
    2121        disp('      boundary conditions for diagnostic model: spc set as observed velocities');
    2222        md.diagnostic.spcvx(pos)=md.inversion.vx_obs(pos);
    … …  
    3535%Create zeros basal melting rate and surface mass balance if not specified
    3636if isnan(md.surfaceforcings.accumulation_rate),
    37         md.surfaceforcings.accumulation_rate=zeros(md.numberofnodes,1);
     37        md.surfaceforcings.accumulation_rate=zeros(md.mesh.numberofvertices,1);
    3838        disp('      no surfaceforcings.accumulation_rate specified: values set as zero');
    3939end
    4040if isnan(md.surfaceforcings.ablation_rate),
    41         md.surfaceforcings.ablation_rate=zeros(md.numberofnodes,1);
     41        md.surfaceforcings.ablation_rate=zeros(md.mesh.numberofvertices,1);
    4242        disp('      no surfaceforcings.ablation_rate specified: values set as zero');
    4343end
    4444if isnan(md.surfaceforcings.mass_balance),
    45         md.surfaceforcings.mass_balance=zeros(md.numberofnodes,1);
     45        md.surfaceforcings.mass_balance=zeros(md.mesh.numberofvertices,1);
    4646        disp('      no surfaceforcings.mass_balance specified: values set as zero');
    4747end
    4848if isnan(md.basalforcings.melting_rate),
    49         md.basalforcings.melting_rate=zeros(md.numberofnodes,1);
     49        md.basalforcings.melting_rate=zeros(md.mesh.numberofvertices,1);
    5050        disp('      no basalforcings.melting_rate specified: values set as zero');
    5151end
    5252if isnan(md.balancethickness.thickening_rate),
    53         md.balancethickness.thickening_rate=zeros(md.numberofnodes,1);
     53        md.balancethickness.thickening_rate=zeros(md.mesh.numberofvertices,1);
    5454        disp('      no balancethickness.thickening_rate specified: values set as zero');
    5555end
    5656
    57 md.prognostic.spcthickness=NaN*ones(md.numberofnodes,1);
    58 md.balancethickness.spcthickness=NaN*ones(md.numberofnodes,1);
     57md.prognostic.spcthickness=NaN*ones(md.mesh.numberofvertices,1);
     58md.balancethickness.spcthickness=NaN*ones(md.mesh.numberofvertices,1);
    5959
    60 if (length(md.initialization.temperature)==md.numberofnodes),
    61         md.thermal.spctemperature=NaN*ones(md.numberofnodes,1);
     60if (length(md.initialization.temperature)==md.mesh.numberofvertices),
     61        md.thermal.spctemperature=NaN*ones(md.mesh.numberofvertices,1);
    6262        pos=find(md.nodeonsurface); md.thermal.spctemperature(pos)=md.initialization.temperature(pos); %impose observed temperature on surface
    63         if (length(md.basalforcings.geothermalflux)~=md.numberofnodes),
    64                 md.basalforcings.geothermalflux=50*10^-3*ones(md.numberofnodes,1); %50 mW/m^2
     63        if (length(md.basalforcings.geothermalflux)~=md.mesh.numberofvertices),
     64                md.basalforcings.geothermalflux=50*10^-3*ones(md.mesh.numberofvertices,1); %50 mW/m^2
    6565        end
    6666else

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

    r9719 r9725  
    2222        nodeonicefront=double(md.mesh.vertexonboundary & nodeinsideicefront);
    2323elseif nargin==1,
    24         nodeonicefront=zeros(md.numberofnodes,1);
     24        nodeonicefront=zeros(md.mesh.numberofvertices,1);
    2525else
    2626        help SetIceShelfBC
    … …  
    2828end
    2929pos=find(md.mesh.vertexonboundary & ~nodeonicefront);
    30 md.diagnostic.spcvx=NaN*ones(md.numberofnodes,1);
    31 md.diagnostic.spcvy=NaN*ones(md.numberofnodes,1);
    32 md.diagnostic.spcvz=NaN*ones(md.numberofnodes,1);
     30md.diagnostic.spcvx=NaN*ones(md.mesh.numberofvertices,1);
     31md.diagnostic.spcvy=NaN*ones(md.mesh.numberofvertices,1);
     32md.diagnostic.spcvz=NaN*ones(md.mesh.numberofvertices,1);
    3333md.diagnostic.spcvx(pos)=0;
    3434md.diagnostic.spcvy(pos)=0;
    3535md.diagnostic.spcvz(pos)=0;
    36 md.diagnostic.referential=NaN*ones(md.numberofnodes,6);
     36md.diagnostic.referential=NaN*ones(md.mesh.numberofvertices,6);
    3737
    3838%Dirichlet Values
    39 if (length(md.inversion.vx_obs)==md.numberofnodes & length(md.inversion.vy_obs)==md.numberofnodes)
     39if (length(md.inversion.vx_obs)==md.mesh.numberofvertices & length(md.inversion.vy_obs)==md.mesh.numberofvertices)
    4040        disp('      boundary conditions for diagnostic model: spc set as observed velocities');
    4141        md.diagnostic.spcvx(pos)=md.inversion.vx_obs(pos);
    … …  
    5151        pressureload=md.mesh.segments(pos,:);
    5252elseif md.mesh.dimension==3
    53         pressureload_layer1=[md.mesh.segments(pos,1:2)  md.mesh.segments(pos,2)+md.numberofnodes2d  md.mesh.segments(pos,1)+md.numberofnodes2d  md.mesh.segments(pos,3)];
     53        pressureload_layer1=[md.mesh.segments(pos,1:2)  md.mesh.segments(pos,2)+md.mesh.numberofvertices2d  md.mesh.segments(pos,1)+md.mesh.numberofvertices2d  md.mesh.segments(pos,3)];
    5454        pressureload=[];
    55         for i=1:md.numlayers-1,
    56                 pressureload=[pressureload ;pressureload_layer1(:,1:4)+(i-1)*md.numberofnodes2d pressureload_layer1(:,5)+(i-1)*md.numberofelements2d ];
     55        for i=1:md.mesh.numberoflayers-1,
     56                pressureload=[pressureload ;pressureload_layer1(:,1:4)+(i-1)*md.mesh.numberofvertices2d pressureload_layer1(:,5)+(i-1)*md.mesh.numberofelements2d ];
    5757        end
    5858end
    … …  
    6767% and surfaceforcings.mass_balance if not specified
    6868if isnan(md.surfaceforcings.accumulation_rate),
    69         md.surfaceforcings.accumulation_rate=zeros(md.numberofnodes,1);
     69        md.surfaceforcings.accumulation_rate=zeros(md.mesh.numberofvertices,1);
    7070        disp('      no surfaceforcings.accumulation_rate specified: values set as zero');
    7171end
    7272if isnan(md.surfaceforcings.ablation_rate),
    73         md.surfaceforcings.ablation_rate=zeros(md.numberofnodes,1);
     73        md.surfaceforcings.ablation_rate=zeros(md.mesh.numberofvertices,1);
    7474        disp('      no surfaceforcings.ablation_rate specified: values set as zero');
    7575end
    7676if isnan(md.surfaceforcings.mass_balance),
    77         md.surfaceforcings.mass_balance=zeros(md.numberofnodes,1);
     77        md.surfaceforcings.mass_balance=zeros(md.mesh.numberofvertices,1);
    7878        disp('      no surfaceforcings.mass_balance specified: values set as zero');
    7979end
    8080if isnan(md.basalforcings.melting_rate),
    81         md.basalforcings.melting_rate=zeros(md.numberofnodes,1);
     81        md.basalforcings.melting_rate=zeros(md.mesh.numberofvertices,1);
    8282        disp('      no basalforcings.melting_rate specified: values set as zero');
    8383end
    8484if isnan(md.balancethickness.thickening_rate),
    85         md.balancethickness.thickening_rate=zeros(md.numberofnodes,1);
     85        md.balancethickness.thickening_rate=zeros(md.mesh.numberofvertices,1);
    8686        disp('      no balancethickness.thickening_rate specified: values set as zero');
    8787end
    8888
    89 md.prognostic.spcthickness=NaN*ones(md.numberofnodes,1);
    90 md.balancethickness.spcthickness=NaN*ones(md.numberofnodes,1);
     89md.prognostic.spcthickness=NaN*ones(md.mesh.numberofvertices,1);
     90md.balancethickness.spcthickness=NaN*ones(md.mesh.numberofvertices,1);
    9191
    92 if (length(md.initialization.temperature)==md.numberofnodes),
    93         md.thermal.spctemperature=NaN*ones(md.numberofnodes,1);
     92if (length(md.initialization.temperature)==md.mesh.numberofvertices),
     93        md.thermal.spctemperature=NaN*ones(md.mesh.numberofvertices,1);
    9494        pos=find(md.nodeonsurface); md.thermal.spctemperature(pos)=md.initialization.temperature(pos); %impose observed temperature on surface
    95         if (length(md.basalforcings.geothermalflux)~=md.numberofnodes),
    96                 md.basalforcings.geothermalflux=zeros(md.numberofnodes,1);
     95        if (length(md.basalforcings.geothermalflux)~=md.mesh.numberofvertices),
     96                md.basalforcings.geothermalflux=zeros(md.mesh.numberofvertices,1);
    9797        end
    9898else

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

    r9719 r9725  
    2727else
    2828        %Guess where the ice front is
    29         vertexonfloatingice=zeros(md.numberofnodes,1);
     29        vertexonfloatingice=zeros(md.mesh.numberofvertices,1);
    3030        vertexonfloatingice(md.elements(find(md.mask.elementonfloatingice),:))=1;
    3131        vertexonicefront=double(md.mesh.vertexonboundary & vertexonfloatingice);
    … …  
    3535        warning('SetMarineIceSheetBC warning: ice front all around the glacier, no dirichlet found. Dirichlet must be added manually')
    3636end
    37 md.diagnostic.spcvx=NaN*ones(md.numberofnodes,1);
    38 md.diagnostic.spcvy=NaN*ones(md.numberofnodes,1);
    39 md.diagnostic.spcvz=NaN*ones(md.numberofnodes,1);
     37md.diagnostic.spcvx=NaN*ones(md.mesh.numberofvertices,1);
     38md.diagnostic.spcvy=NaN*ones(md.mesh.numberofvertices,1);
     39md.diagnostic.spcvz=NaN*ones(md.mesh.numberofvertices,1);
    4040md.diagnostic.spcvx(pos)=0;
    4141md.diagnostic.spcvy(pos)=0;
    4242md.diagnostic.spcvz(pos)=0;
    43 md.diagnostic.referential=NaN*ones(md.numberofnodes,6);
     43md.diagnostic.referential=NaN*ones(md.mesh.numberofvertices,6);
    4444
    4545%Dirichlet Values
    46 if (length(md.inversion.vx_obs)==md.numberofnodes & length(md.inversion.vy_obs)==md.numberofnodes)
     46if (length(md.inversion.vx_obs)==md.mesh.numberofvertices & length(md.inversion.vy_obs)==md.mesh.numberofvertices)
    4747        disp('      boundary conditions for diagnostic model: spc set as observed velocities');
    4848        md.diagnostic.spcvx(pos)=md.inversion.vx_obs(pos);
    … …  
    5252end
    5353
    54 md.hydrology.spcwatercolumn=zeros(md.numberofnodes,2);
     54md.hydrology.spcwatercolumn=zeros(md.mesh.numberofvertices,2);
    5555pos=find(md.mesh.vertexonboundary);
    5656md.hydrology.spcwatercolumn(pos,1)=1;
    … …  
    6161        pressureload=md.mesh.segments(pos,:);
    6262elseif md.mesh.dimension==3
    63         pressureload_layer1=[md.mesh.segments(pos,1:2)  md.mesh.segments(pos,2)+md.numberofnodes2d  md.mesh.segments(pos,1)+md.numberofnodes2d  md.mesh.segments(pos,3)];
     63        pressureload_layer1=[md.mesh.segments(pos,1:2)  md.mesh.segments(pos,2)+md.mesh.numberofvertices2d  md.mesh.segments(pos,1)+md.mesh.numberofvertices2d  md.mesh.segments(pos,3)];
    6464        pressureload=[];
    65         for i=1:md.numlayers-1,
    66                 pressureload=[pressureload ;pressureload_layer1(:,1:4)+(i-1)*md.numberofnodes2d pressureload_layer1(:,5)+(i-1)*md.numberofelements2d ];
     65        for i=1:md.mesh.numberoflayers-1,
     66                pressureload=[pressureload ;pressureload_layer1(:,1:4)+(i-1)*md.mesh.numberofvertices2d pressureload_layer1(:,5)+(i-1)*md.mesh.numberofelements2d ];
    6767        end
    6868end
    … …  
    7878% and surfaceforcings.mass_balance if not specified
    7979if isnan(md.surfaceforcings.accumulation_rate),
    80         md.surfaceforcings.accumulation_rate=zeros(md.numberofnodes,1);
     80        md.surfaceforcings.accumulation_rate=zeros(md.mesh.numberofvertices,1);
    8181        disp('      no surfaceforcings.accumulation_rate specified: values set as zero');
    8282end
    8383if isnan(md.surfaceforcings.ablation_rate),
    84         md.surfaceforcings.ablation_rate=zeros(md.numberofnodes,1);
     84        md.surfaceforcings.ablation_rate=zeros(md.mesh.numberofvertices,1);
    8585        disp('      no surfaceforcings.ablation_rate specified: values set as zero');
    8686end
    8787if isnan(md.surfaceforcings.mass_balance),
    88         md.surfaceforcings.mass_balance=zeros(md.numberofnodes,1);
     88        md.surfaceforcings.mass_balance=zeros(md.mesh.numberofvertices,1);
    8989        disp('      no surfaceforcings.mass_balance specified: values set as zero');
    9090end
    9191if isnan(md.basalforcings.melting_rate),
    92         md.basalforcings.melting_rate=zeros(md.numberofnodes,1);
     92        md.basalforcings.melting_rate=zeros(md.mesh.numberofvertices,1);
    9393        disp('      no basalforcings.melting_rate specified: values set as zero');
    9494end
    9595if isnan(md.balancethickness.thickening_rate),
    96         md.balancethickness.thickening_rate=zeros(md.numberofnodes,1);
     96        md.balancethickness.thickening_rate=zeros(md.mesh.numberofvertices,1);
    9797        disp('      no balancethickness.thickening_rate specified: values set as zero');
    9898end
    9999
    100 md.prognostic.spcthickness=NaN*ones(md.numberofnodes,1);
    101 md.balancethickness.spcthickness=NaN*ones(md.numberofnodes,1);
     100md.prognostic.spcthickness=NaN*ones(md.mesh.numberofvertices,1);
     101md.balancethickness.spcthickness=NaN*ones(md.mesh.numberofvertices,1);
    102102
    103 if (length(md.initialization.temperature)==md.numberofnodes),
    104         md.thermal.spctemperature=NaN*ones(md.numberofnodes,1);
     103if (length(md.initialization.temperature)==md.mesh.numberofvertices),
     104        md.thermal.spctemperature=NaN*ones(md.mesh.numberofvertices,1);
    105105        pos=find(md.nodeonsurface); md.thermal.spctemperature(pos)=md.initialization.temperature(pos); %impose observed temperature on surface
    106         if (length(md.basalforcings.geothermalflux)~=md.numberofnodes),
    107                 md.basalforcings.geothermalflux=zeros(md.numberofnodes,1);
     106        if (length(md.basalforcings.geothermalflux)~=md.mesh.numberofvertices),
     107                md.basalforcings.geothermalflux=zeros(md.mesh.numberofvertices,1);
    108108                md.basalforcings.geothermalflux(find(md.mask.vertexongroundedice))=50*10^-3; %50mW/m2
    109109        end

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

    r9641 r9725  
    1616        if ischar(region),
    1717                if isempty(region),
    18                         flag=zeros(md.numberofelements,1);
     18                        flag=zeros(md.mesh.numberofelements,1);
    1919                        invert=0;
    2020                elseif strcmpi(region,'all')
    21                         flag=ones(md.numberofelements,1);
     21                        flag=ones(md.mesh.numberofelements,1);
    2222                        invert=0;
    2323                else
    … …  
    4444                end
    4545        elseif isfloat(region) | islogical(region),
    46                 if size(region,1)~=md.numberofelements,
     46                if size(region,1)~=md.mesh.numberofelements,
    4747                        help FlagElements
    4848                        error('Flaglist for region must be of same size as number of elements in model');

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

    r9681 r9725  
    2525%Compute metric
    2626t1=clock; fprintf('%s','      computing metric...');
    27 if length(md.nodeonwater)==md.numberofnodes,
     27if length(md.nodeonwater)==md.mesh.numberofvertices,
    2828        pos=find(md.nodeonwater);
    2929else
    … …  
    3636t1=clock; fprintf('%s','      writing initial mesh files...');
    3737fid=fopen('carre0.met','w');
    38 fprintf(fid,'%i %i\n',md.numberofnodes,3);
     38fprintf(fid,'%i %i\n',md.mesh.numberofvertices,3);
    3939fprintf(fid,'%i %i %i\n',metric');
    4040fclose(fid);
    … …  
    4949
    5050%Vertices
    51 fprintf(fid,'\n%s\n%i\n\n','Vertices',md.numberofnodes);
    52 fprintf(fid,'%8g %8g %i\n',[md.x md.y ones(md.numberofnodes,1)]');
     51fprintf(fid,'\n%s\n%i\n\n','Vertices',md.mesh.numberofvertices);
     52fprintf(fid,'%8g %8g %i\n',[md.x md.y ones(md.mesh.numberofvertices,1)]');
    5353
    5454%Triangles
    55 fprintf(fid,'\n\n%s\n%i\n\n','Triangles',md.numberofelements);
    56 fprintf(fid,'%i %i %i %i\n',[md.elements ones(md.numberofelements,1)]');
    57 numberofelements1=md.numberofelements;
     55fprintf(fid,'\n\n%s\n%i\n\n','Triangles',md.mesh.numberofelements);
     56fprintf(fid,'%i %i %i %i\n',[md.elements ones(md.mesh.numberofelements,1)]');
     57numberofelements1=md.mesh.numberofelements;
    5858
    5959%close
    … …  
    7272md.z=zeros(A.nods,1);
    7373md.elements=A.index;
    74 md.numberofnodes=A.nods;
    75 md.numberofelements=A.nels;
    76 numberofelements2=md.numberofelements;
     74md.mesh.numberofvertices=A.nods;
     75md.mesh.numberofelements=A.nels;
     76numberofelements2=md.mesh.numberofelements;
    7777t2=clock;fprintf('%s\n\n',[' done (' num2str(etime(t2,t1)) ' seconds)']);
    7878

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

    r8298 r9725  
    1717t1=clock; fprintf('%s','      writing initial mesh files...');
    1818fid=fopen('carre0.met','w');
    19 fprintf(fid,'%i %i\n',md.numberofnodes,3);
     19fprintf(fid,'%i %i\n',md.mesh.numberofvertices,3);
    2020fprintf(fid,'%i %i %i\n',metric');
    2121fclose(fid);
    … …  
    3030
    3131%Vertices
    32 fprintf(fid,'\n%s\n%i\n\n','Vertices',md.numberofnodes);
    33 fprintf(fid,'%8g %8g %i\n',[md.x md.y ones(md.numberofnodes,1)]');
     32fprintf(fid,'\n%s\n%i\n\n','Vertices',md.mesh.numberofvertices);
     33fprintf(fid,'%8g %8g %i\n',[md.x md.y ones(md.mesh.numberofvertices,1)]');
    3434
    3535%Triangles
    36 fprintf(fid,'\n\n%s\n%i\n\n','Triangles',md.numberofelements);
    37 fprintf(fid,'%i %i %i %i\n',[md.elements ones(md.numberofelements,1)]');
    38 numberofelements1=md.numberofelements;
     36fprintf(fid,'\n\n%s\n%i\n\n','Triangles',md.mesh.numberofelements);
     37fprintf(fid,'%i %i %i %i\n',[md.elements ones(md.mesh.numberofelements,1)]');
     38numberofelements1=md.mesh.numberofelements;
    3939
    4040%close
    … …  
    5353md.z=zeros(A.nods,1);
    5454md.elements=A.index;
    55 md.numberofnodes=A.nods;
    56 md.numberofelements=A.nels;
    57 numberofelements2=md.numberofelements;
     55md.mesh.numberofvertices=A.nods;
     56md.mesh.numberofelements=A.nels;
     57numberofelements2=md.mesh.numberofelements;
    5858t2=clock;fprintf('%s\n\n',[' done (' num2str(etime(t2,t1)) ' seconds)']);
    5959

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

    r9681 r9725  
    1717
    1818%Compute metric
    19 if length(md.nodeonwater)==md.numberofnodes,
     19if length(md.nodeonwater)==md.mesh.numberofvertices,
    2020        pos=find(md.nodeonwater);
    2121else
    … …  
    6060lambda1=min(max(abs(lambda1)*scale/epsilon,1/hmax^2),1/hmin^2);
    6161lambda2=min(max(abs(lambda2)*scale/epsilon,1/hmax^2),1/hmin^2);
    62 if length(md.nodeonwater)==md.numberofnodes;
     62if length(md.nodeonwater)==md.mesh.numberofvertices;
    6363        pos=find(md.nodeonwater);
    6464        lambda1(pos)=0;

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

    r9681 r9725  
    2525%Compute metric
    2626t1=clock; fprintf('%s','      computing metric...');
    27 if length(md.nodeonwater)==md.numberofnodes,
     27if length(md.nodeonwater)==md.mesh.numberofvertices,
    2828        pos=find(md.nodeonwater);
    2929else
    … …  
    4646
    4747%Vertices
    48 fprintf(fid,'\n%s\n%i\n\n','Vertices',md.numberofnodes);
    49 fprintf(fid,'%8g %8g %i\n',[md.x md.y zeros(md.numberofnodes,1)]');
     48fprintf(fid,'\n%s\n%i\n\n','Vertices',md.mesh.numberofvertices);
     49fprintf(fid,'%8g %8g %i\n',[md.x md.y zeros(md.mesh.numberofvertices,1)]');
    5050
    5151%Triangles
    52 fprintf(fid,'\n\n%s\n%i\n\n','Triangles',md.numberofelements);
    53 fprintf(fid,'%i %i %i %i\n',[md.elements zeros(md.numberofelements,1)]');
    54 numberofelements1=md.numberofelements;
     52fprintf(fid,'\n\n%s\n%i\n\n','Triangles',md.mesh.numberofelements);
     53fprintf(fid,'%i %i %i %i\n',[md.elements zeros(md.mesh.numberofelements,1)]');
     54numberofelements1=md.mesh.numberofelements;
    5555       
    5656%Deal with rifts
    … …  
    9292md.z=zeros(size(Coor,1),1);
    9393md.elements=Tria;
    94 md.numberofnodes=size(Coor,1);
    95 md.numberofelements=size(Tria,1);
    96 numberofelements2=md.numberofelements;
     94md.mesh.numberofvertices=size(Coor,1);
     95md.mesh.numberofelements=size(Tria,1);
     96numberofelements2=md.mesh.numberofelements;
    9797t2=clock;fprintf('%s\n\n',[' done (' num2str(etime(t2,t1)) ' seconds)']);
    9898

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

    r9719 r9725  
    8181md.y=y;
    8282md.z=z;
    83 md.numberofnodes=size(md.x,1);
    84 md.numberofelements=size(md.elements,1);
    85 md.nodeonbed=ones(md.numberofnodes,1);
    86 md.nodeonsurface=ones(md.numberofnodes,1);
    87 md.elementonbed=ones(md.numberofelements,1);
    88 md.elementonsurface=ones(md.numberofelements,1);
     83md.mesh.numberofvertices=size(md.x,1);
     84md.mesh.numberofelements=size(md.elements,1);
     85md.nodeonbed=ones(md.mesh.numberofvertices,1);
     86md.nodeonsurface=ones(md.mesh.numberofvertices,1);
     87md.elementonbed=ones(md.mesh.numberofelements,1);
     88md.elementonsurface=ones(md.mesh.numberofelements,1);
    8989md.mesh.dimension=2;
    9090md=addnote(md,notes);
    … …  
    9292%Add segments and nodes on boundary
    9393md.mesh.segments=findsegments(md);
    94 md.mesh.vertexonboundary=zeros(md.numberofnodes,1);
     94md.mesh.vertexonboundary=zeros(md.mesh.numberofvertices,1);
    9595md.mesh.vertexonboundary(md.mesh.segments(:,1))=1;
    9696md.mesh.vertexonboundary(md.mesh.segments(:,2))=1;

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

    r9719 r9725  
    5959md.y=y;
    6060md.z=zeros(nods,1);
    61 md.numberofnodes=nods;
     61md.mesh.numberofvertices=nods;
    6262md.mesh.vertexonboundary=zeros(nods,1);md.mesh.vertexonboundary(segments(:,1:2))=1;
    6363md.nodeonbed=ones(nods,1);
    … …  
    6767md.elements=index;
    6868md.mesh.segments=segments;
    69 md.numberofelements=nel;
     69md.mesh.numberofelements=nel;
    7070md.elementonbed=ones(nel,1);
    7171md.elementonsurface=ones(nel,1);
    7272
    7373%Now, build the connectivity tables for this mesh.
    74 md.nodeconnectivity=NodeConnectivity(md.elements,md.numberofnodes);
     74md.nodeconnectivity=NodeConnectivity(md.elements,md.mesh.numberofvertices);
    7575md.elementconnectivity=ElementConnectivity(md.elements,md.nodeconnectivity);
    7676

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

    r8298 r9725  
    1111
    1212%Check length of velocities
    13 if size(vx,1)~=md.numberofnodes & size(vy,1)~=md.numberofnodes,
    14         error('timestpes error message: size of velocity components must be the same as md.numberofnodes');
     13if size(vx,1)~=md.mesh.numberofvertices & size(vy,1)~=md.mesh.numberofvertices,
     14        error('timestpes error message: size of velocity components must be the same as md.mesh.numberofvertices');
    1515end
    1616

  • issm/trunk/template

    r9714 r9725  
    66          z
    77          elements
    8           dim -> rename dimension
    9           numlayers -> rename numberoflayers
    10           numberofelements
    11           numberofnodes -> rename numberofvertices as well as nodeon...
    128          edges
    139
    … …  
    1713          lowernodes
    1814
    19           numberofelements2d
    20           numberofnodes2d
    2115          elements2d
    2216          x2d

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

    r9705 r9725  
    1414
    1515md.drag_type=2; %0 none 1 plastic 2 viscous
    16 md.drag_coefficient=30*ones(md.numberofnodes,1); %q=1.
     16md.drag_coefficient=30*ones(md.mesh.numberofvertices,1); %q=1.
    1717%Take care of iceshelves: no basal drag
    1818pos=find(md.mask.elementonfloatingice);
    1919md.drag_coefficient(md.elements(pos,:))=0;
    20 md.drag_p=ones(md.numberofelements,1);
    21 md.drag_q=ones(md.numberofelements,1);
     20md.drag_p=ones(md.mesh.numberofelements,1);
     21md.drag_q=ones(md.mesh.numberofelements,1);
    2222
    23 md.observed_temperature=(273-20)*ones(md.numberofnodes,1);
     23md.observed_temperature=(273-20)*ones(md.mesh.numberofvertices,1);
    2424
    2525md.materials.rheology_B=paterson(md.observed_temperature);
    26 md.materials.rheology_n=3*ones(md.numberofelements,1);
     26md.materials.rheology_n=3*ones(md.mesh.numberofelements,1);
    2727
    2828%Deal with boundary conditions:
    2929md=SetIceSheetBC(md);
    30 md.diagnostic.spcvx=zeros(md.numberofnodes,1);
    31 md.diagnostic.spcvy=200*ones(md.numberofnodes,1);
     30md.diagnostic.spcvx=zeros(md.mesh.numberofvertices,1);
     31md.diagnostic.spcvy=200*ones(md.mesh.numberofvertices,1);
    3232
    3333%Parallel options

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

    r9702 r9725  
    1111
    1212%Materials
    13 md.observed_temperature=(273-20)*ones(md.numberofnodes,1);
     13md.observed_temperature=(273-20)*ones(md.mesh.numberofvertices,1);
    1414md.materials.rheology_B=paterson(md.observed_temperature);
    15 md.materials.rheology_n=3*ones(md.numberofelements,1);
     15md.materials.rheology_n=3*ones(md.mesh.numberofelements,1);
    1616md.initialization.temperature=md.observed_temperature;
    1717
    … …  
    1919pos=find(md.mask.elementonfloatingice);
    2020md.drag_type=2;
    21 md.drag_coefficient=20*ones(md.numberofnodes,1);
     21md.drag_coefficient=20*ones(md.mesh.numberofvertices,1);
    2222md.drag_coefficient(md.elements(pos,:))=0;
    23 md.drag_p=ones(md.numberofelements,1);
    24 md.drag_q=ones(md.numberofelements,1);
     23md.drag_p=ones(md.mesh.numberofelements,1);
     24md.drag_q=ones(md.mesh.numberofelements,1);
    2525
    2626%Numerical parameters

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

    r9702 r9725  
    1616
    1717md.drag_type=2; %0 none 1 plastic 2 viscous
    18 md.drag_coefficient=200*ones(md.numberofnodes,1); %q=1.
     18md.drag_coefficient=200*ones(md.mesh.numberofvertices,1); %q=1.
    1919%Take care of iceshelves: no basal drag
    2020pos=find(md.mask.elementonfloatingice);
    2121md.drag_coefficient(md.elements(pos,:))=0;
    22 md.drag_p=ones(md.numberofelements,1);
    23 md.drag_q=ones(md.numberofelements,1);
     22md.drag_p=ones(md.mesh.numberofelements,1);
     23md.drag_q=ones(md.mesh.numberofelements,1);
    2424md.viscosity_overshoot=0.3;
    2525
    26 md.observed_temperature=(273-20)*ones(md.numberofnodes,1);
     26md.observed_temperature=(273-20)*ones(md.mesh.numberofvertices,1);
    2727
    2828md.materials.rheology_B=paterson(md.observed_temperature);
    29 md.materials.rheology_n=3*ones(md.numberofelements,1);
     29md.materials.rheology_n=3*ones(md.mesh.numberofelements,1);
    3030
    3131%Deal with boundary conditions:

  • issm/trunk/test/Miscellaneous/connectivity/runme.m

    r9705 r9725  
    6060
    6161        end
    62         numelements(i)=md.numberofelements;
     62        numelements(i)=md.mesh.numberofelements;
    6363end
    6464

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

    r9679 r9725  
    2121
    2222        %Create dirichlet on the bed only
    23         md.diagnostic.spcvx=NaN*ones(md.numberofnodes,1);
    24         md.diagnostic.spcvy=NaN*ones(md.numberofnodes,1);
    25         md.diagnostic.spcvz=NaN*ones(md.numberofnodes,1);
     23        md.diagnostic.spcvx=NaN*ones(md.mesh.numberofvertices,1);
     24        md.diagnostic.spcvy=NaN*ones(md.mesh.numberofvertices,1);
     25        md.diagnostic.spcvz=NaN*ones(md.mesh.numberofvertices,1);
    2626
    2727        pos=find(md.nodeonbed);
    … …  
    4747        vz=PatchToVec(md.results.DiagnosticSolution.Vz);
    4848        results{i}=md.results.DiagnosticSolution;
    49         minvx(i)=min(vx(end-md.numberofnodes2d+1:end));
    50         maxvx(i)=max(vx(end-md.numberofnodes2d+1:end));
     49        minvx(i)=min(vx(end-md.mesh.numberofvertices2d+1:end));
     50        maxvx(i)=max(vx(end-md.mesh.numberofvertices2d+1:end));
    5151
    5252        %Now plot vx, vy, vz and vx on a cross section
    53         plotmodel(md,'data',vx,'layer#all',md.numlayers,'xlim',[0 L/10^3],'ylim',[0 L/10^3],'unit','km')
     53        plotmodel(md,'data',vx,'layer#all',md.mesh.numberoflayers,'xlim',[0 L/10^3],'ylim',[0 L/10^3],'unit','km')
    5454        if printingflag,
    5555                set(gcf,'Color','w')
    … …  
    5757                system(['mv ismipapattynvx' num2str(L) '.png ' ISSM_DIR '/website/doc_pdf/validation/Images/ISMIP/TestA ']);
    5858        end
    59         plotmodel(md,'data',vy,'layer#all',md.numlayers,'xlim',[0 L/10^3],'ylim',[0 L/10^3],'unit','km')
     59        plotmodel(md,'data',vy,'layer#all',md.mesh.numberoflayers,'xlim',[0 L/10^3],'ylim',[0 L/10^3],'unit','km')
    6060        if printingflag,
    6161                set(gcf,'Color','w')
    … …  
    6363                system(['mv ismipapattynvy' num2str(L) '.png ' ISSM_DIR '/website/doc_pdf/validation/Images/ISMIP/TestA ']);
    6464        end
    65         plotmodel(md,'data',vz,'layer#all',md.numlayers,'xlim',[0 L/10^3],'ylim',[0 L/10^3],'unit','km')
     65        plotmodel(md,'data',vz,'layer#all',md.mesh.numberoflayers,'xlim',[0 L/10^3],'ylim',[0 L/10^3],'unit','km')
    6666        if printingflag,
    6767                set(gcf,'Color','w')
    … …  
    7171
    7272        if(L==5000),
    73                 plotmodel(md,'data',vx,'sectionvalue','../Exp/ISMIP5000.exp','layer',md.numlayers,...
     73                plotmodel(md,'data',vx,'sectionvalue','../Exp/ISMIP5000.exp','layer',md.mesh.numberoflayers,...
    7474                        'resolution',[10 10],'ylim',[10 18],'xlim',[0 5000],'title','','xlabel','')
    7575        elseif(L==10000),
    76                 plotmodel(md,'data',vx,'sectionvalue','../Exp/ISMIP10000.exp','layer',md.numlayers,...
     76                plotmodel(md,'data',vx,'sectionvalue','../Exp/ISMIP10000.exp','layer',md.mesh.numberoflayers,...
    7777                        'resolution',[10 10],'ylim',[10 30],'xlim',[0 10000],'title','','xlabel','')
    7878        elseif(L==20000),
    79                 plotmodel(md,'data',vx,'sectionvalue','../Exp/ISMIP20000.exp','layer',md.numlayers,...
     79                plotmodel(md,'data',vx,'sectionvalue','../Exp/ISMIP20000.exp','layer',md.mesh.numberoflayers,...
    8080                        'resolution',[10 10],'ylim',[0 50],'xlim',[0 20000],'title','','xlabel','')
    8181        elseif(L==40000),
    82                 plotmodel(md,'data',vx,'sectionvalue','../Exp/ISMIP40000.exp','layer',md.numlayers,...
     82                plotmodel(md,'data',vx,'sectionvalue','../Exp/ISMIP40000.exp','layer',md.mesh.numberoflayers,...
    8383                        'resolution',[10 10],'ylim',[0 80],'xlim',[0 40000],'title','','xlabel','')
    8484        elseif(L==80000),
    85                 plotmodel(md,'data',vx,'sectionvalue','../Exp/ISMIP80000.exp','layer',md.numlayers,...
     85                plotmodel(md,'data',vx,'sectionvalue','../Exp/ISMIP80000.exp','layer',md.mesh.numberoflayers,...
    8686                        'resolution',[10 10],'ylim',[0 100],'xlim',[0 80000],'title','','xlabel','')
    8787        elseif(L==160000),
    88                 plotmodel(md,'data',vx,'sectionvalue','../Exp/ISMIP160000.exp','layer',md.numlayers,...
     88                plotmodel(md,'data',vx,'sectionvalue','../Exp/ISMIP160000.exp','layer',md.mesh.numberoflayers,...
    8989                        'resolution',[10 10],'ylim',[0 120],'xlim',[0 160000],'title','','xlabel','')
    9090        end

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

    r9679 r9725  
    1919%       posnodes=find((md.x==0 | md.x==max(md.x)) & (md.y==0 | md.y==max(md.y)));
    2020%       [a,b]=find(ismember(md.elements,posnodes));
    21 %       elements=ones(md.numberofelements,1);
     21%       elements=ones(md.mesh.numberofelements,1);
    2222%       elements(a)=0;
    2323%       md=modelextract(md,elements);
    … …  
    5757        pressure=PatchToVec(md.results.DiagnosticSolution.Pressure);
    5858        results{i}=md.results.DiagnosticSolution;
    59         minvx(i)=min(vx(end-md.numberofnodes2d+1:end));
    60         maxvx(i)=max(vx(end-md.numberofnodes2d+1:end));
     59        minvx(i)=min(vx(end-md.mesh.numberofvertices2d+1:end));
     60        maxvx(i)=max(vx(end-md.mesh.numberofvertices2d+1:end));
    6161
    6262        %Now plot vx, vy, vz and vx on a cross section
    63         plotmodel(md,'data',vx,'layer#all',md.numlayers,'xlim',[0 L/10^3],'ylim',[0 L/10^3],'unit','km','figure',2)
     63        plotmodel(md,'data',vx,'layer#all',md.mesh.numberoflayers,'xlim',[0 L/10^3],'ylim',[0 L/10^3],'unit','km','figure',2)
    6464        if printingflag,
    6565                set(gcf,'Color','w')
    … …  
    6767                system(['mv ismipastokesvx' num2str(L) '.png ' ISSM_DIR '/website/doc_pdf/validation/Images/ISMIP/TestA ']);
    6868        end
    69         plotmodel(md,'data',vy,'layer#all',md.numlayers,'xlim',[0 L/10^3],'ylim',[0 L/10^3],'unit','km','figure',3)
     69        plotmodel(md,'data',vy,'layer#all',md.mesh.numberoflayers,'xlim',[0 L/10^3],'ylim',[0 L/10^3],'unit','km','figure',3)
    7070        if printingflag,
    7171                set(gcf,'Color','w')
    … …  
    7373                system(['mv ismipastokesvy' num2str(L) '.png ' ISSM_DIR '/website/doc_pdf/validation/Images/ISMIP/TestA ']);
    7474        end
    75         plotmodel(md,'data',vz,'layer#all',md.numlayers,'xlim',[0 L/10^3],'ylim',[0 L/10^3],'unit','km','figure',4)
     75        plotmodel(md,'data',vz,'layer#all',md.mesh.numberoflayers,'xlim',[0 L/10^3],'ylim',[0 L/10^3],'unit','km','figure',4)
    7676        if printingflag,
    7777                set(gcf,'Color','w')
    … …  
    8181
    8282        if(L==5000),
    83                 plotmodel(md,'data',vx,'sectionvalue','../Exp/ISMIP5000.exp','layer',md.numlayers,...
     83                plotmodel(md,'data',vx,'sectionvalue','../Exp/ISMIP5000.exp','layer',md.mesh.numberoflayers,...
    8484                        'resolution',[10 10],'ylim',[10 18],'xlim',[0 5000],'title','','xlabel','')
    8585        elseif(L==10000),
    86                 plotmodel(md,'data',vx,'sectionvalue','../Exp/ISMIP10000.exp','layer',md.numlayers,...
     86                plotmodel(md,'data',vx,'sectionvalue','../Exp/ISMIP10000.exp','layer',md.mesh.numberoflayers,...
    8787                        'resolution',[10 10],'ylim',[10 30],'xlim',[0 10000],'title','','xlabel','')
    8888        elseif(L==20000),
    89                 plotmodel(md,'data',vx,'sectionvalue','../Exp/ISMIP20000.exp','layer',md.numlayers,...
     89                plotmodel(md,'data',vx,'sectionvalue','../Exp/ISMIP20000.exp','layer',md.mesh.numberoflayers,...
    9090                        'resolution',[10 10],'ylim',[0 50],'xlim',[0 20000],'title','','xlabel','')
    9191        elseif(L==40000),
    92                 plotmodel(md,'data',vx,'sectionvalue','../Exp/ISMIP40000.exp','layer',md.numlayers,...
     92                plotmodel(md,'data',vx,'sectionvalue','../Exp/ISMIP40000.exp','layer',md.mesh.numberoflayers,...
    9393                        'resolution',[10 10],'ylim',[0 80],'xlim',[0 40000],'title','','xlabel','')
    9494        elseif(L==80000),
    95                 plotmodel(md,'data',vx,'sectionvalue','../Exp/ISMIP80000.exp','layer',md.numlayers,...
     95                plotmodel(md,'data',vx,'sectionvalue','../Exp/ISMIP80000.exp','layer',md.mesh.numberoflayers,...
    9696                        'resolution',[10 10],'ylim',[0 100],'xlim',[0 80000],'title','','xlabel','')
    9797        elseif(L==160000),
    98                 plotmodel(md,'data',vx,'sectionvalue','../Exp/ISMIP160000.exp','layer',md.numlayers,...
     98                plotmodel(md,'data',vx,'sectionvalue','../Exp/ISMIP160000.exp','layer',md.mesh.numberoflayers,...
    9999                        'resolution',[10 10],'ylim',[0 120],'xlim',[0 160000],'title','','xlabel','')
    100100        end

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

    r9679 r9725  
    1919
    2020        %Create dirichlet on the bed only
    21         md.diagnostic.spcvx=NaN*ones(md.numberofnodes,1);
    22         md.diagnostic.spcvy=NaN*ones(md.numberofnodes,1);
    23         md.diagnostic.spcvz=NaN*ones(md.numberofnodes,1);
     21        md.diagnostic.spcvx=NaN*ones(md.mesh.numberofvertices,1);
     22        md.diagnostic.spcvy=NaN*ones(md.mesh.numberofvertices,1);
     23        md.diagnostic.spcvz=NaN*ones(md.mesh.numberofvertices,1);
    2424        pos=find(md.nodeonbed);
    2525        md.diagnostic.spcvx(pos)=0;
    … …  
    4444        vz=PatchToVec(md.results.DiagnosticSolution.Vz);
    4545        results{i}=md.results.DiagnosticSolution;
    46         minvx(i)=min(vx(end-md.numberofnodes2d+1:end));
    47         maxvx(i)=max(vx(end-md.numberofnodes2d+1:end));
     46        minvx(i)=min(vx(end-md.mesh.numberofvertices2d+1:end));
     47        maxvx(i)=max(vx(end-md.mesh.numberofvertices2d+1:end));
    4848
    4949        %Now plot vx, vy, vz and vx on a cross section
    50         plotmodel(md,'data',vx,'layer#all',md.numlayers,'xlim',[0 L/10^3],'ylim',[0 L/10^3],'unit','km')
     50        plotmodel(md,'data',vx,'layer#all',md.mesh.numberoflayers,'xlim',[0 L/10^3],'ylim',[0 L/10^3],'unit','km')
    5151        if printingflag,
    5252                set(gcf,'Color','w')
    … …  
    5454                system(['mv ismipbpattynvx' num2str(L) '.png ' ISSM_DIR '/website/doc_pdf/validation/Images/ISMIP/TestB ']);
    5555        end
    56         plotmodel(md,'data',vz,'layer#all',md.numlayers,'xlim',[0 L/10^3],'ylim',[0 L/10^3],'unit','km')
     56        plotmodel(md,'data',vz,'layer#all',md.mesh.numberoflayers,'xlim',[0 L/10^3],'ylim',[0 L/10^3],'unit','km')
    5757        if printingflag,
    5858                set(gcf,'Color','w')
    … …  
    6262
    6363        if(L==5000),
    64                 plotmodel(md,'data',vx,'sectionvalue','../Exp/ISMIP5000.exp','layer',md.numlayers,...
     64                plotmodel(md,'data',vx,'sectionvalue','../Exp/ISMIP5000.exp','layer',md.mesh.numberoflayers,...
    6565                        'resolution',[10 10],'ylim',[6 16],'xlim',[0 5000],'title','','xlabel','')
    6666        elseif(L==10000),
    67                 plotmodel(md,'data',vx,'sectionvalue','../Exp/ISMIP10000.exp','layer',md.numlayers,...
     67                plotmodel(md,'data',vx,'sectionvalue','../Exp/ISMIP10000.exp','layer',md.mesh.numberoflayers,...
    6868                        'resolution',[10 10],'ylim',[0 40],'xlim',[0 10000],'title','','xlabel','')
    6969        elseif(L==20000),
    70                 plotmodel(md,'data',vx,'sectionvalue','../Exp/ISMIP20000.exp','layer',md.numlayers,...
     70                plotmodel(md,'data',vx,'sectionvalue','../Exp/ISMIP20000.exp','layer',md.mesh.numberoflayers,...
    7171                        'resolution',[10 10],'ylim',[0 60],'xlim',[0 20000],'title','','xlabel','')
    7272        elseif(L==40000),
    73                 plotmodel(md,'data',vx,'sectionvalue','../Exp/ISMIP40000.exp','layer',md.numlayers,...
     73                plotmodel(md,'data',vx,'sectionvalue','../Exp/ISMIP40000.exp','layer',md.mesh.numberoflayers,...
    7474                        'resolution',[10 10],'ylim',[0 100],'xlim',[0 40000],'title','','xlabel','')
    7575        elseif(L==80000),
    76                 plotmodel(md,'data',vx,'sectionvalue','../Exp/ISMIP80000.exp','layer',md.numlayers,...
     76                plotmodel(md,'data',vx,'sectionvalue','../Exp/ISMIP80000.exp','layer',md.mesh.numberoflayers,...
    7777                        'resolution',[10 10],'ylim',[0 120],'xlim',[0 80000],'title','','xlabel','')
    7878        elseif(L==160000),
    79                 plotmodel(md,'data',vx,'sectionvalue','../Exp/ISMIP160000.exp','layer',md.numlayers,...
     79                plotmodel(md,'data',vx,'sectionvalue','../Exp/ISMIP160000.exp','layer',md.mesh.numberoflayers,...
    8080                        'resolution',[10 10],'ylim',[0 120],'xlim',[0 160000],'title','','xlabel','')
    8181        end

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

    r9679 r9725  
    1818
    1919        %Create dirichlet on the bed only
    20         md.diagnostic.spcvx=NaN*ones(md.numberofnodes,1);
    21         md.diagnostic.spcvy=NaN*ones(md.numberofnodes,1);
    22         md.diagnostic.spcvz=NaN*ones(md.numberofnodes,1);
     20        md.diagnostic.spcvx=NaN*ones(md.mesh.numberofvertices,1);
     21        md.diagnostic.spcvy=NaN*ones(md.mesh.numberofvertices,1);
     22        md.diagnostic.spcvz=NaN*ones(md.mesh.numberofvertices,1);
    2323
    2424        pos=find(md.nodeonbed);
    … …  
    4545        results{i}=md.results.DiagnosticSolution;
    4646
    47         plotmodel(md,'data',vx,'data',vy,'data',vz,'layer#all',md.numlayers)
     47        plotmodel(md,'data',vx,'data',vy,'data',vz,'layer#all',md.mesh.numberoflayers)
    4848end
    4949

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

    r9679 r9725  
    2121
    2222        %Create MPCs to have periodic boundary conditions
    23         md.diagnostic.spcvx=NaN*ones(md.numberofnodes,1);
    24         md.diagnostic.spcvy=NaN*ones(md.numberofnodes,1);
    25         md.diagnostic.spcvz=NaN*ones(md.numberofnodes,1);
     23        md.diagnostic.spcvx=NaN*ones(md.mesh.numberofvertices,1);
     24        md.diagnostic.spcvy=NaN*ones(md.mesh.numberofvertices,1);
     25        md.diagnostic.spcvz=NaN*ones(md.mesh.numberofvertices,1);
    2626
    2727        posx=find(md.x==0 & md.y~=0 & md.y~=L);
    … …  
    7070        vz=PatchToVec(md.results.DiagnosticSolution.Vz);
    7171        results{i}=md.results.DiagnosticSolution;
    72         minvx(i)=min(vx(end-md.numberofnodes2d+1:end));
    73         maxvx(i)=max(vx(end-md.numberofnodes2d+1:end));
     72        minvx(i)=min(vx(end-md.mesh.numberofvertices2d+1:end));
     73        maxvx(i)=max(vx(end-md.mesh.numberofvertices2d+1:end));
    7474
    7575        %Now plot vx, vy, vz and vx on a cross section
    76         plotmodel(md,'data',vx,'layer#all',md.numlayers,'xlim',[0 L/10^3],'ylim',[0 L/10^3],'unit','km','figure',2)
     76        plotmodel(md,'data',vx,'layer#all',md.mesh.numberoflayers,'xlim',[0 L/10^3],'ylim',[0 L/10^3],'unit','km','figure',2)
    7777        if printingflag,
    7878                set(gcf,'Color','w')
    … …  
    8080                system(['mv ismipcpattynvx' num2str(L) '.png ' ISSM_DIR '/website/doc_pdf/validation/Images/ISMIP/TestC ']);
    8181        end
    82         plotmodel(md,'data',vy,'layer#all',md.numlayers,'xlim',[0 L/10^3],'ylim',[0 L/10^3],'unit','km','figure',3)
     82        plotmodel(md,'data',vy,'layer#all',md.mesh.numberoflayers,'xlim',[0 L/10^3],'ylim',[0 L/10^3],'unit','km','figure',3)
    8383        if printingflag,
    8484                set(gcf,'Color','w')
    … …  
    8686                system(['mv ismipcpattynvy' num2str(L) '.png ' ISSM_DIR '/website/doc_pdf/validation/Images/ISMIP/TestC ']);
    8787        end
    88         plotmodel(md,'data',vz,'layer#all',md.numlayers,'xlim',[0 L/10^3],'ylim',[0 L/10^3],'unit','km','figure',4)
     88        plotmodel(md,'data',vz,'layer#all',md.mesh.numberoflayers,'xlim',[0 L/10^3],'ylim',[0 L/10^3],'unit','km','figure',4)
    8989        if printingflag,
    9090                set(gcf,'Color','w')
    … …  
    9494
    9595        if(L==5000),
    96                 plotmodel(md,'data',vx,'sectionvalue','../Exp/ISMIP5000.exp','layer',md.numlayers,...
     96                plotmodel(md,'data',vx,'sectionvalue','../Exp/ISMIP5000.exp','layer',md.mesh.numberoflayers,...
    9797                        'resolution',[10 10],'ylim',[0 20],'xlim',[0 5000],'title','','xlabel','','figure',5)
    9898        elseif(L==10000),
    99                 plotmodel(md,'data',vx,'sectionvalue','../Exp/ISMIP10000.exp','layer',md.numlayers,...
     99                plotmodel(md,'data',vx,'sectionvalue','../Exp/ISMIP10000.exp','layer',md.mesh.numberoflayers,...
    100100                        'resolution',[10 10],'ylim',[13 18],'xlim',[0 10000],'title','','xlabel','')
    101101        elseif(L==20000),
    102                 plotmodel(md,'data',vx,'sectionvalue','../Exp/ISMIP20000.exp','layer',md.numlayers,...
     102                plotmodel(md,'data',vx,'sectionvalue','../Exp/ISMIP20000.exp','layer',md.mesh.numberoflayers,...
    103103                        'resolution',[10 10],'ylim',[14 22],'xlim',[0 20000],'title','','xlabel','')
    104104        elseif(L==40000),
    105                 plotmodel(md,'data',vx,'sectionvalue','../Exp/ISMIP40000.exp','layer',md.numlayers,...
     105                plotmodel(md,'data',vx,'sectionvalue','../Exp/ISMIP40000.exp','layer',md.mesh.numberoflayers,...
    106106                        'resolution',[10 10],'ylim',[10 40],'xlim',[0 40000],'title','','xlabel','')
    107107        elseif(L==80000),
    108                 plotmodel(md,'data',vx,'sectionvalue','../Exp/ISMIP80000.exp','layer',md.numlayers,...
     108                plotmodel(md,'data',vx,'sectionvalue','../Exp/ISMIP80000.exp','layer',md.mesh.numberoflayers,...
    109109                        'resolution',[10 10],'ylim',[0 80],'xlim',[0 80000],'title','','xlabel','')
    110110        elseif(L==160000),
    111                 plotmodel(md,'data',vx,'sectionvalue','../Exp/ISMIP160000.exp','layer',md.numlayers,...
     111                plotmodel(md,'data',vx,'sectionvalue','../Exp/ISMIP160000.exp','layer',md.mesh.numberoflayers,...
    112112                        'resolution',[10 10],'ylim',[0 200],'xlim',[0 160000],'title','','xlabel','')
    113113        end

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

    r9679 r9725  
    3838        results{i}=md.results.DiagnosticSolution;
    3939
    40         plotmodel(md,'data',vx,'data',vy,'data',vz,'layer#all',md.numlayers)
     40        plotmodel(md,'data',vx,'data',vy,'data',vz,'layer#all',md.mesh.numberoflayers)
    4141end
    4242

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

    r9679 r9725  
    2121
    2222        %We need one grd on dirichlet: the 4 corners are set to zero
    23         md.diagnostic.spcvx=NaN*ones(md.numberofnodes,1);
    24         md.diagnostic.spcvy=NaN*ones(md.numberofnodes,1);
    25         md.diagnostic.spcvz=NaN*ones(md.numberofnodes,1);
     23        md.diagnostic.spcvx=NaN*ones(md.mesh.numberofvertices,1);
     24        md.diagnostic.spcvy=NaN*ones(md.mesh.numberofvertices,1);
     25        md.diagnostic.spcvz=NaN*ones(md.mesh.numberofvertices,1);
    2626
    2727        %Create MPCs to have periodic boundary conditions
    … …  
    6565        vz=PatchToVec(md.results.DiagnosticSolution.Vz);
    6666        results{i}=md.results.DiagnosticSolution;
    67         minvx(i)=min(vx(end-md.numberofnodes2d+1:end));
    68         maxvx(i)=max(vx(end-md.numberofnodes2d+1:end));
     67        minvx(i)=min(vx(end-md.mesh.numberofvertices2d+1:end));
     68        maxvx(i)=max(vx(end-md.mesh.numberofvertices2d+1:end));
    6969
    7070        %Now plot vx, vy, vz and vx on a cross section
    71         plotmodel(md,'data',vx,'layer#all',md.numlayers,'xlim',[0 L/10^3],'ylim',[0 L/10^3],'unit','km','figure',2)
     71        plotmodel(md,'data',vx,'layer#all',md.mesh.numberoflayers,'xlim',[0 L/10^3],'ylim',[0 L/10^3],'unit','km','figure',2)
    7272        if printingflag,
    7373                set(gcf,'Color','w')
    … …  
    7575                system(['mv ismipdpattynvx' num2str(L) '.png ' ISSM_DIR '/website/doc_pdf/validation/Images/ISMIP/TestD ']);
    7676        end
    77         plotmodel(md,'data',vz,'layer#all',md.numlayers,'xlim',[0 L/10^3],'ylim',[0 L/10^3],'unit','km','figure',3)
     77        plotmodel(md,'data',vz,'layer#all',md.mesh.numberoflayers,'xlim',[0 L/10^3],'ylim',[0 L/10^3],'unit','km','figure',3)
    7878        if printingflag,
    7979                set(gcf,'Color','w')
    … …  
    8383
    8484        if(L==5000),
    85                 plotmodel(md,'data',vx,'sectionvalue','../Exp/ISMIP5000.exp','layer',md.numlayers,...
     85                plotmodel(md,'data',vx,'sectionvalue','../Exp/ISMIP5000.exp','layer',md.mesh.numberoflayers,...
    8686                        'resolution',[10 10],'ylim',[0 20],'xlim',[0 5000],'title','','xlabel','','figure',4)
    8787        elseif(L==10000),
    88                 plotmodel(md,'data',vx,'sectionvalue','../Exp/ISMIP10000.exp','layer',md.numlayers,...
     88                plotmodel(md,'data',vx,'sectionvalue','../Exp/ISMIP10000.exp','layer',md.mesh.numberoflayers,...
    8989                        'resolution',[10 10],'ylim',[0 20],'xlim',[0 10000],'title','','xlabel','','figure',4)
    9090        elseif(L==20000),
    91                 plotmodel(md,'data',vx,'sectionvalue','../Exp/ISMIP20000.exp','layer',md.numlayers,...
     91                plotmodel(md,'data',vx,'sectionvalue','../Exp/ISMIP20000.exp','layer',md.mesh.numberoflayers,...
    9292                        'resolution',[10 10],'ylim',[0 30],'xlim',[0 20000],'title','','xlabel','','figure',4)
    9393        elseif(L==40000),
    94                 plotmodel(md,'data',vx,'sectionvalue','../Exp/ISMIP40000.exp','layer',md.numlayers,...
     94                plotmodel(md,'data',vx,'sectionvalue','../Exp/ISMIP40000.exp','layer',md.mesh.numberoflayers,...
    9595                        'resolution',[10 10],'ylim',[10 60],'xlim',[0 40000],'title','','xlabel','','figure',4)
    9696        elseif(L==80000),
    97                 plotmodel(md,'data',vx,'sectionvalue','../Exp/ISMIP80000.exp','layer',md.numlayers,...
     97                plotmodel(md,'data',vx,'sectionvalue','../Exp/ISMIP80000.exp','layer',md.mesh.numberoflayers,...
    9898                        'resolution',[10 10],'ylim',[0 200],'xlim',[0 80000],'title','','xlabel','','figure',4)
    9999        elseif(L==160000),
    100                 plotmodel(md,'data',vx,'sectionvalue','../Exp/ISMIP160000.exp','layer',md.numlayers,...
     100                plotmodel(md,'data',vx,'sectionvalue','../Exp/ISMIP160000.exp','layer',md.mesh.numberoflayers,...
    101101                        'resolution',[10 10],'ylim',[0 400],'xlim',[0 160000],'title','','xlabel','','figure',4)
    102102        end

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

    r9679 r9725  
    1818
    1919        %We need one grd on dirichlet: the 4 corners are set to zero
    20         %md.diagnostic.spcvx=NaN*ones(md.numberofnodes,1);
    21         %md.diagnostic.spcvy=NaN*ones(md.numberofnodes,1);
    22         %md.diagnostic.spcvz=NaN*ones(md.numberofnodes,1);
     20        %md.diagnostic.spcvx=NaN*ones(md.mesh.numberofvertices,1);
     21        %md.diagnostic.spcvy=NaN*ones(md.mesh.numberofvertices,1);
     22        %md.diagnostic.spcvz=NaN*ones(md.mesh.numberofvertices,1);
    2323       
    2424        %pos=find((md.x==0 | md.x==max(md.x)) & (md.y==0 | md.y==max(md.y)));
    … …  
    4646        results{i}=md.results.DiagnosticSolution;
    4747
    48         plotmodel(md,'data',vx,'data',vy,'data',vz,'layer#all',md.numlayers)
     48        plotmodel(md,'data',vx,'data',vy,'data',vz,'layer#all',md.mesh.numberoflayers)
    4949end
    5050

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

    r9679 r9725  
    3232        %Create spcs on the bed
    3333        pos=find(md.nodeonbed);
    34         md.diagnostic.spcvx=NaN*ones(md.numberofnodes,1);
    35         md.diagnostic.spcvy=NaN*ones(md.numberofnodes,1);
    36         md.diagnostic.spcvz=NaN*ones(md.numberofnodes,1);
     34        md.diagnostic.spcvx=NaN*ones(md.mesh.numberofvertices,1);
     35        md.diagnostic.spcvy=NaN*ones(md.mesh.numberofvertices,1);
     36        md.diagnostic.spcvz=NaN*ones(md.mesh.numberofvertices,1);
    3737        md.diagnostic.spcvx(pos)=0;
    3838        md.diagnostic.spcvy(pos)=0;
    … …  
    5757
    5858        if i==1,
    59                 plotmodel(md,'data',vy,'ylim',[-10 80],'layer',md.numlayers,'sectionvalue','../Exp/ISMIPE.exp','resolution',[10 10],'title','','xlabel','')
     59                plotmodel(md,'data',vy,'ylim',[-10 80],'layer',md.mesh.numberoflayers,'sectionvalue','../Exp/ISMIPE.exp','resolution',[10 10],'title','','xlabel','')
    6060                if printingflag,
    6161                        set(gcf,'Color','w')
    … …  
    6464                end
    6565        elseif i==2,
    66                 plotmodel(md,'data',vy,'ylim',[-10 80],'layer',md.numlayers,'sectionvalue','../Exp/ISMIPE.exp','resolution',[10 10],'title','','xlabel','')
     66                plotmodel(md,'data',vy,'ylim',[-10 80],'layer',md.mesh.numberoflayers,'sectionvalue','../Exp/ISMIPE.exp','resolution',[10 10],'title','','xlabel','')
    6767                if printingflag,
    6868                        set(gcf,'Color','w')
    … …  
    7171                end
    7272        elseif i==3,
    73                 plotmodel(md,'data',vy,'ylim',[-50 200],'layer',md.numlayers,'sectionvalue','../Exp/ISMIPE.exp','resolution',[10 10],'title','','xlabel','')
     73                plotmodel(md,'data',vy,'ylim',[-50 200],'layer',md.mesh.numberoflayers,'sectionvalue','../Exp/ISMIPE.exp','resolution',[10 10],'title','','xlabel','')
    7474                if printingflag,
    7575                        set(gcf,'Color','w')
    … …  
    7878                end
    7979        elseif i==4,
    80                 plotmodel(md,'data',vy,'ylim',[-50 200],'layer',md.numlayers,'sectionvalue','../Exp/ISMIPE.exp','resolution',[10 10],'title','','xlabel','')
     80                plotmodel(md,'data',vy,'ylim',[-50 200],'layer',md.mesh.numberoflayers,'sectionvalue','../Exp/ISMIPE.exp','resolution',[10 10],'title','','xlabel','')
    8181                if printingflag,
    8282                        set(gcf,'Color','w')

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

    r9703 r9725  
    2020        end
    2121
    22         md.diagnostic.spcvx=NaN*ones(md.numberofnodes,1);
    23         md.diagnostic.spcvy=NaN*ones(md.numberofnodes,1);
    24         md.diagnostic.spcvz=NaN*ones(md.numberofnodes,1);
     22        md.diagnostic.spcvx=NaN*ones(md.mesh.numberofvertices,1);
     23        md.diagnostic.spcvy=NaN*ones(md.mesh.numberofvertices,1);
     24        md.diagnostic.spcvz=NaN*ones(md.mesh.numberofvertices,1);
    2525        if (i==1 | i==3),
    2626                %Create dirichlet on the bed if no slip
    … …  
    6464        %Now plot vx and delta surface
    6565        if (i==1 | i==3),
    66                 plotmodel(md,'data',PatchToVec(md.results.TransientSolution(end).Vx),'layer',md.numlayers,'sectionvalue','../Exp/ISMIP100000.exp','title','','xlabel','','ylabel','Velocity (m/yr)','linewidth',3,'grid','on','unit','km','ylim',[91 100])
     66                plotmodel(md,'data',PatchToVec(md.results.TransientSolution(end).Vx),'layer',md.mesh.numberoflayers,'sectionvalue','../Exp/ISMIP100000.exp','title','','xlabel','','ylabel','Velocity (m/yr)','linewidth',3,'grid','on','unit','km','ylim',[91 100])
    6767        elseif (i==2 | i==4),
    68                 plotmodel(md,'data',PatchToVec(md.results.TransientSolution(end).Vx),'layer',md.numlayers,'sectionvalue','../Exp/ISMIP100000.exp','title','','xlabel','','ylabel','Velocity (m/yr)','linewidth',3,'grid','on','unit','km','ylim',[185 200])
     68                plotmodel(md,'data',PatchToVec(md.results.TransientSolution(end).Vx),'layer',md.mesh.numberoflayers,'sectionvalue','../Exp/ISMIP100000.exp','title','','xlabel','','ylabel','Velocity (m/yr)','linewidth',3,'grid','on','unit','km','ylim',[185 200])
    6969        end
    7070        if printingflag,
    … …  
    8585        end
    8686
    87         plotmodel(md,'data',PatchToVec(md.results.TransientSolution(end).Surface)-md.geometry.surface,'layer',md.numlayers,'sectionvalue','../Exp/ISMIP100000.exp','title','','xlabel','','ylabel','Surface (m)','linewidth',3,'grid','on','unit','km','ylim',[-30 50])
     87        plotmodel(md,'data',PatchToVec(md.results.TransientSolution(end).Surface)-md.geometry.surface,'layer',md.mesh.numberoflayers,'sectionvalue','../Exp/ISMIP100000.exp','title','','xlabel','','ylabel','Surface (m)','linewidth',3,'grid','on','unit','km','ylim',[-30 50])
    8888        if printingflag,
    8989                set(gcf,'Color','w')

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

    r9684 r9725  
    1414
    1515        disp('      initial velocity');
    16         md.initialization.vx=zeros(md.numberofnodes,1);
    17         md.initialization.vy=-400*ones(md.numberofnodes,1);
     16        md.initialization.vx=zeros(md.mesh.numberofvertices,1);
     17        md.initialization.vy=-400*ones(md.mesh.numberofvertices,1);
    1818
    1919        %Stabilization
    … …  
    2929        pos=find(md.y>199999.9);
    3030        times=0:1:500;
    31         md.prognostic.spcthickness=NaN*ones(md.numberofnodes+1,length(times));
     31        md.prognostic.spcthickness=NaN*ones(md.mesh.numberofvertices+1,length(times));
    3232        md.prognostic.spcthickness(end,:)=times;
    3333        md.prognostic.spcthickness(pos,:)=repmat(500+100*sin(2*pi*times/200),length(pos),1);

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

    r9691 r9725  
    3434vx=PatchToVec(md.results.DiagnosticSolution.Vx);
    3535vy=PatchToVec(md.results.DiagnosticSolution.Vy);
    36 vel=zeros(md.numberofnodes2d,1);
     36vel=zeros(md.mesh.numberofvertices2d,1);
    3737
    3838node_vel=0;
    39 for i=1:md.numberofnodes2d
    40         for j=1:(md.numlayers-1)
    41                 node_vel=node_vel+1/(2*(md.numlayers-1))*(sqrt(vx(i+j*md.numberofnodes2d,1).^2+...
    42                         vy(i+j*md.numberofnodes2d,1).^2)+...
    43                         sqrt(vx(i+(j-1)*md.numberofnodes2d,1).^2+vy(i+(j-1)*md.numberofnodes2d,1).^2));
     39for i=1:md.mesh.numberofvertices2d
     40        for j=1:(md.mesh.numberoflayers-1)
     41                node_vel=node_vel+1/(2*(md.mesh.numberoflayers-1))*(sqrt(vx(i+j*md.mesh.numberofvertices2d,1).^2+...
     42                        vy(i+j*md.mesh.numberofvertices2d,1).^2)+...
     43                        sqrt(vx(i+(j-1)*md.mesh.numberofvertices2d,1).^2+vy(i+(j-1)*md.mesh.numberofvertices2d,1).^2));
    4444        end
    4545        vel(i,1)=node_vel;
    … …  
    6666subplot(2,2,3)
    6767hold on;
    68 plot(sqrt((md.x(1:md.numberofnodes2d)).^2+(md.y(1:md.numberofnodes2d)).^2),vel,'r.');
     68plot(sqrt((md.x(1:md.mesh.numberofvertices2d)).^2+(md.y(1:md.mesh.numberofvertices2d)).^2),vel,'r.');
    6969plot(sqrt((md.x2d).^2+(md.y2d).^2),vel_obs,'b.');
    7070title('Analytical vs calculated velocity','FontSize',14,'FontWeight','bold');

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

    r9691 r9725  
    3434vx=PatchToVec(md.results.DiagnosticSolution.Vx);
    3535vy=PatchToVec(md.results.DiagnosticSolution.Vy);
    36 vel=zeros(md.numberofnodes2d,1);
     36vel=zeros(md.mesh.numberofvertices2d,1);
    3737
    3838node_vel=0;
    39 for i=1:md.numberofnodes2d
    40         for j=1:(md.numlayers-1)
    41                 node_vel=node_vel+1/(2*(md.numlayers-1))*(sqrt(vx(i+j*md.numberofnodes2d,1).^2+...
    42                         vy(i+j*md.numberofnodes2d,1).^2)+...
    43                         sqrt(vx(i+(j-1)*md.numberofnodes2d,1).^2+vy(i+(j-1)*md.numberofnodes2d,1).^2));
     39for i=1:md.mesh.numberofvertices2d
     40        for j=1:(md.mesh.numberoflayers-1)
     41                node_vel=node_vel+1/(2*(md.mesh.numberoflayers-1))*(sqrt(vx(i+j*md.mesh.numberofvertices2d,1).^2+...
     42                        vy(i+j*md.mesh.numberofvertices2d,1).^2)+...
     43                        sqrt(vx(i+(j-1)*md.mesh.numberofvertices2d,1).^2+vy(i+(j-1)*md.mesh.numberofvertices2d,1).^2));
    4444        end
    4545        vel(i,1)=node_vel;
    … …  
    6565subplot(2,2,3)
    6666hold on;
    67 plot(sqrt((md.x(1:md.numberofnodes2d)).^2+(md.y(1:md.numberofnodes2d)).^2),vel,'r.');
     67plot(sqrt((md.x(1:md.mesh.numberofvertices2d)).^2+(md.y(1:md.mesh.numberofvertices2d)).^2),vel,'r.');
    6868plot(sqrt((md.x2d).^2+(md.y2d).^2),vel_obs,'b.');
    6969title('Analytical vs calculated velocity','FontSize',14,'FontWeight','bold');

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

    r9691 r9725  
    3434vx=PatchToVec(md.results.DiagnosticSolution.Vx);
    3535vy=PatchToVec(md.results.DiagnosticSolution.Vy);
    36 vel=zeros(md.numberofnodes2d,1);
     36vel=zeros(md.mesh.numberofvertices2d,1);
    3737
    3838node_vel=0;
    39 for i=1:md.numberofnodes2d
    40         for j=1:(md.numlayers-1)
    41                 node_vel=node_vel+1/(2*(md.numlayers-1))*(sqrt(vx(i+j*md.numberofnodes2d,1).^2+...
    42                         vy(i+j*md.numberofnodes2d,1).^2)+...
    43                         sqrt(vx(i+(j-1)*md.numberofnodes2d,1).^2+vy(i+(j-1)*md.numberofnodes2d,1).^2));
     39for i=1:md.mesh.numberofvertices2d
     40        for j=1:(md.mesh.numberoflayers-1)
     41                node_vel=node_vel+1/(2*(md.mesh.numberoflayers-1))*(sqrt(vx(i+j*md.mesh.numberofvertices2d,1).^2+...
     42                        vy(i+j*md.mesh.numberofvertices2d,1).^2)+...
     43                        sqrt(vx(i+(j-1)*md.mesh.numberofvertices2d,1).^2+vy(i+(j-1)*md.mesh.numberofvertices2d,1).^2));
    4444        end
    4545        vel(i,1)=node_vel;
    … …  
    6565subplot(2,2,3)
    6666hold on;
    67 plot(sqrt((md.x(1:md.numberofnodes2d)).^2+(md.y(1:md.numberofnodes2d)).^2),vel,'r.');
     67plot(sqrt((md.x(1:md.mesh.numberofvertices2d)).^2+(md.y(1:md.mesh.numberofvertices2d)).^2),vel,'r.');
    6868plot(sqrt((md.x2d).^2+(md.y2d).^2),vel_obs,'b.');
    6969title('Analytical vs calculated velocity','FontSize',14,'FontWeight','bold');

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

    r9703 r9725  
    1313
    1414%Some conditions specific to melting test
    15 md.initialization.pressure=zeros(md.numberofnodes,1);
    16 md.initialization.temperature=273.15*ones(md.numberofnodes,1);
     15md.initialization.pressure=zeros(md.mesh.numberofvertices,1);
     16md.initialization.temperature=273.15*ones(md.mesh.numberofvertices,1);
    1717pos=find(md.nodeonsurface);
    1818md.thermal.spctemperature(pos)=md.initialization.temperature(pos);
    … …  
    2929
    3030%plot results
    31 comp_melting=zeros(md.numberofnodes,1);
     31comp_melting=zeros(md.mesh.numberofvertices,1);
    3232comp_melting(md.results.ThermalSolution.BasalforcingsMeltingRate.index)=md.results.ThermalSolution.BasalforcingsMeltingRate.value;
    3333relative=abs((comp_melting-melting)./melting)*100;

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

    r9703 r9725  
    1414pos1=find(md.elementonbed);     md.thermal.spctemperature(md.elements(pos1,1:3))=10;
    1515pos2=find(md.elementonsurface); md.thermal.spctemperature(md.elements(pos2,4:6))=0;
    16 md.initialization.vz=0.1*ones(md.numberofnodes,1);
     16md.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);
    18 md.initialization.pressure=zeros(md.numberofnodes,1);
     18md.initialization.pressure=zeros(md.mesh.numberofvertices,1);
    1919
    2020%analytical results
    … …  
    3030
    3131%plot results
    32 comp_temp=zeros(md.numberofnodes,1);
     32comp_temp=zeros(md.mesh.numberofvertices,1);
    3333comp_temp(md.results.ThermalSolution.Temperature.index)=md.results.ThermalSolution.Temperature.value;
    3434relative=abs((comp_temp-md.initialization.temperature)./md.initialization.temperature)*100;

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

    r9703 r9725  
    1313pos1=find(md.elementonbed);     md.thermal.spctemperature(md.elements(pos1,1:3))=10;
    1414pos2=find(md.elementonsurface); md.thermal.spctemperature(md.elements(pos2,4:6))=0;
    15 md.initialization.pressure=zeros(md.numberofnodes,1);
     15md.initialization.pressure=zeros(md.mesh.numberofvertices,1);
    1616
    1717%analytical results
    … …  
    2525
    2626%plot results
    27 comp_temp=zeros(md.numberofnodes,1);
     27comp_temp=zeros(md.mesh.numberofvertices,1);
    2828comp_temp(md.results.ThermalSolution.Temperature.index)=md.results.ThermalSolution.Temperature.value;
    2929relative=abs((comp_temp-md.initialization.temperature)./md.initialization.temperature)*100;

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

    r9703 r9725  
    1313
    1414pos2=find(md.elementonsurface); md.thermal.spctemperature(md.elements(pos2,4:6))=0;
    15 md.initialization.pressure=zeros(md.numberofnodes,1);
     15md.initialization.pressure=zeros(md.mesh.numberofvertices,1);
    1616md.basalforcings.geothermalflux(:)=0.1; %100mW/m^2
    1717
    … …  
    2626
    2727%plot results
    28 comp_temp=zeros(md.numberofnodes,1);
     28comp_temp=zeros(md.mesh.numberofvertices,1);
    2929comp_temp(md.results.ThermalSolution.Temperature.index)=md.results.ThermalSolution.Temperature.value;
    3030relative=abs((comp_temp-md.initialization.temperature)./md.initialization.temperature)*100;

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

    r5098 r9725  
    1313t0=clock;
    1414md=bamg(model,'domain','../Exp/Square.exp','hmax',3000);
    15 nbelements=md.numberofelements;
     15nbelements=md.mesh.numberofelements;
    1616elapsedtime=etime(clock,t0);
    1717

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

    r9703 r9725  
    1313
    1414%Solve for thinning rate -> -1 * surface mass balance
    15 smb= 2*ones(md.numberofnodes,1);   
     15smb= 2*ones(md.mesh.numberofvertices,1);   
    1616md.surfaceforcings.mass_balance= smb;
    1717md.basalforcings.melting_rate= smb;

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

    r9703 r9725  
    1414
    1515%Solve for thinning rate -> -1 * surface mass balance
    16 smb= 2*ones(md.numberofnodes,1);   
     16smb= 2*ones(md.mesh.numberofvertices,1);   
    1717md.surfaceforcings.mass_balance= smb;
    1818md.basalforcings.melting_rate= smb;

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

    r9703 r9725  
    77md.inversion.iscontrol=1;
    88md.inversion.control_parameters={'MaterialsRheologyBbar'};
    9 md.inversion.min_parameters=10^6*ones(md.numberofnodes,1);
    10 md.inversion.max_parameters=2*10^9*ones(md.numberofnodes,1);
     9md.inversion.min_parameters=10^6*ones(md.mesh.numberofvertices,1);
     10md.inversion.max_parameters=2*10^9*ones(md.mesh.numberofvertices,1);
    1111md.inversion.nsteps=2;
    1212md.inversion.cost_functions=101*ones(md.inversion.nsteps,1);
    13 md.inversion.cost_functions_coefficients=ones(md.numberofnodes,1);
     13md.inversion.cost_functions_coefficients=ones(md.mesh.numberofvertices,1);
    1414md.inversion.gradient_scaling=10^7*ones(md.inversion.nsteps,1);
    1515md.inversion.maxiter_per_step=2*ones(md.inversion.nsteps,1);

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

    r9703 r9725  
    77md.inversion.iscontrol=1;
    88md.inversion.control_parameters={'MaterialsRheologyBbar'};
    9 md.inversion.min_parameters=10^6*ones(md.numberofnodes,1);
    10 md.inversion.max_parameters=2*10^9*ones(md.numberofnodes,1);
     9md.inversion.min_parameters=10^6*ones(md.mesh.numberofvertices,1);
     10md.inversion.max_parameters=2*10^9*ones(md.mesh.numberofvertices,1);
    1111md.inversion.nsteps=2;
    1212md.inversion.cost_functions=101*ones(md.inversion.nsteps,1);
    13 md.inversion.cost_functions_coefficients=ones(md.numberofnodes,1);
     13md.inversion.cost_functions_coefficients=ones(md.mesh.numberofvertices,1);
    1414md.inversion.gradient_scaling=10^7*ones(md.inversion.nsteps,1);
    1515md.inversion.maxiter_per_step=2*ones(md.inversion.nsteps,1);

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

    r9703 r9725  
    88md.inversion.iscontrol=1;
    99md.inversion.control_parameters={'MaterialsRheologyBbar'};
    10 md.inversion.min_parameters=10^6*ones(md.numberofnodes,1);
    11 md.inversion.max_parameters=2*10^9*ones(md.numberofnodes,1);
     10md.inversion.min_parameters=10^6*ones(md.mesh.numberofvertices,1);
     11md.inversion.max_parameters=2*10^9*ones(md.mesh.numberofvertices,1);
    1212md.inversion.nsteps=2;
    1313md.inversion.cost_functions=101*ones(md.inversion.nsteps,1);
    14 md.inversion.cost_functions_coefficients=ones(md.numberofnodes,1);
     14md.inversion.cost_functions_coefficients=ones(md.mesh.numberofvertices,1);
    1515md.inversion.gradient_scaling=10^7*ones(md.inversion.nsteps,1);
    1616md.inversion.maxiter_per_step=2*ones(md.inversion.nsteps,1);

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

    r9703 r9725  
    88md.inversion.iscontrol=1;
    99md.inversion.control_parameters={'MaterialsRheologyBbar'};
    10 md.inversion.min_parameters=10^6*ones(md.numberofnodes,1);
    11 md.inversion.max_parameters=2*10^9*ones(md.numberofnodes,1);
     10md.inversion.min_parameters=10^6*ones(md.mesh.numberofvertices,1);
     11md.inversion.max_parameters=2*10^9*ones(md.mesh.numberofvertices,1);
    1212md.inversion.nsteps=2;
    1313md.inversion.cost_functions=101*ones(md.inversion.nsteps,1);
    14 md.inversion.cost_functions_coefficients=ones(md.numberofnodes,1);
     14md.inversion.cost_functions_coefficients=ones(md.mesh.numberofvertices,1);
    1515md.inversion.gradient_scaling=10^7*ones(md.inversion.nsteps,1);
    1616md.inversion.maxiter_per_step=2*ones(md.inversion.nsteps,1);

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

    r9703 r9725  
    88md.inversion.iscontrol=1;
    99md.inversion.control_parameters={'MaterialsRheologyBbar'};
    10 md.inversion.min_parameters=10^6*ones(md.numberofnodes,1);
    11 md.inversion.max_parameters=2*10^9*ones(md.numberofnodes,1);
     10md.inversion.min_parameters=10^6*ones(md.mesh.numberofvertices,1);
     11md.inversion.max_parameters=2*10^9*ones(md.mesh.numberofvertices,1);
    1212md.inversion.nsteps=2;
    1313md.inversion.cost_functions=101*ones(md.inversion.nsteps,1);
    14 md.inversion.cost_functions_coefficients=ones(md.numberofnodes,1);
     14md.inversion.cost_functions_coefficients=ones(md.mesh.numberofvertices,1);
    1515md.inversion.gradient_scaling=10^7*ones(md.inversion.nsteps,1);
    1616md.inversion.maxiter_per_step=2*ones(md.inversion.nsteps,1);

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

    r9703 r9725  
    88md.inversion.iscontrol=1;
    99md.inversion.control_parameters={'MaterialsRheologyBbar'};
    10 md.inversion.min_parameters=10^6*ones(md.numberofnodes,1);
    11 md.inversion.max_parameters=2*10^9*ones(md.numberofnodes,1);
     10md.inversion.min_parameters=10^6*ones(md.mesh.numberofvertices,1);
     11md.inversion.max_parameters=2*10^9*ones(md.mesh.numberofvertices,1);
    1212md.inversion.nsteps=2;
    1313md.inversion.cost_functions=101*ones(md.inversion.nsteps,1);
    14 md.inversion.cost_functions_coefficients=ones(md.numberofnodes,1);
     14md.inversion.cost_functions_coefficients=ones(md.mesh.numberofvertices,1);
    1515md.inversion.gradient_scaling=10^7*ones(md.inversion.nsteps,1);
    1616md.inversion.maxiter_per_step=2*ones(md.inversion.nsteps,1);

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

    r9703 r9725  
    88md.inversion.iscontrol=1;
    99md.inversion.control_parameters={'MaterialsRheologyBbar'};
    10 md.inversion.min_parameters=10^6*ones(md.numberofnodes,1);
    11 md.inversion.max_parameters=2*10^9*ones(md.numberofnodes,1);
     10md.inversion.min_parameters=10^6*ones(md.mesh.numberofvertices,1);
     11md.inversion.max_parameters=2*10^9*ones(md.mesh.numberofvertices,1);
    1212md.inversion.nsteps=2;
    1313md.inversion.cost_functions=101*ones(md.inversion.nsteps,1);
    14 md.inversion.cost_functions_coefficients=ones(md.numberofnodes,1);
     14md.inversion.cost_functions_coefficients=ones(md.mesh.numberofvertices,1);
    1515md.inversion.gradient_scaling=10^7*ones(md.inversion.nsteps,1);
    1616md.inversion.maxiter_per_step=2*ones(md.inversion.nsteps,1);

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

    r9703 r9725  
    88md.inversion.iscontrol=1;
    99md.inversion.control_parameters={'MaterialsRheologyBbar'};
    10 md.inversion.min_parameters=10^6*ones(md.numberofnodes,1);
    11 md.inversion.max_parameters=2*10^9*ones(md.numberofnodes,1);
     10md.inversion.min_parameters=10^6*ones(md.mesh.numberofvertices,1);
     11md.inversion.max_parameters=2*10^9*ones(md.mesh.numberofvertices,1);
    1212md.inversion.nsteps=2;
    1313md.inversion.cost_functions=101*ones(md.inversion.nsteps,1);
    14 md.inversion.cost_functions_coefficients=ones(md.numberofnodes,1);
     14md.inversion.cost_functions_coefficients=ones(md.mesh.numberofvertices,1);
    1515md.inversion.gradient_scaling=10^7*ones(md.inversion.nsteps,1);
    1616md.inversion.maxiter_per_step=2*ones(md.inversion.nsteps,1);

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

    r9714 r9725  
    2121
    2222h=1000;
    23 md.geometry.thickness=h*ones(md.numberofnodes,1);
     23md.geometry.thickness=h*ones(md.mesh.numberofvertices,1);
    2424md.geometry.bed=-md.materials.rho_ice/md.materials.rho_water*md.geometry.thickness;
    2525md.geometry.surface=md.geometry.bed+md.geometry.thickness;
    2626
    2727%Initial velocity and pressure
    28 md.initialization.vx=zeros(md.numberofnodes,1);
    29 md.initialization.vy=zeros(md.numberofnodes,1);
    30 md.initialization.vz=zeros(md.numberofnodes,1);
    31 md.initialization.pressure=zeros(md.numberofnodes,1);
     28md.initialization.vx=zeros(md.mesh.numberofvertices,1);
     29md.initialization.vy=zeros(md.mesh.numberofvertices,1);
     30md.initialization.vz=zeros(md.mesh.numberofvertices,1);
     31md.initialization.pressure=zeros(md.mesh.numberofvertices,1);
    3232
    3333%Materials
    34 md.initialization.temperature=(273-20)*ones(md.numberofnodes,1);
     34md.initialization.temperature=(273-20)*ones(md.mesh.numberofvertices,1);
    3535md.materials.rheology_B=paterson(md.initialization.temperature);
    36 md.materials.rheology_n=3*ones(md.numberofelements,1);
     36md.materials.rheology_n=3*ones(md.mesh.numberofelements,1);
    3737
    3838%Boundary conditions:
    39 md.diagnostic.spcvx=NaN*ones(md.numberofnodes,1);
    40 md.diagnostic.spcvy=NaN*ones(md.numberofnodes,1);
    41 md.diagnostic.spcvz=NaN*ones(md.numberofnodes,1);
     39md.diagnostic.spcvx=NaN*ones(md.mesh.numberofvertices,1);
     40md.diagnostic.spcvy=NaN*ones(md.mesh.numberofvertices,1);
     41md.diagnostic.spcvz=NaN*ones(md.mesh.numberofvertices,1);
    4242
    4343%constrain flanks to 0 normal velocity
    … …  
    5252
    5353%icefront
    54 nodeonicefront=zeros(md.numberofnodes,1);
     54nodeonicefront=zeros(md.mesh.numberofvertices,1);
    5555pos=find(md.y==ymax); nodeonicefront(pos)=1;
    5656pos=find(nodeonicefront(md.mesh.segments(:,1)) | nodeonicefront(md.mesh.segments(:,2))); diagnostic.icefront=md.mesh.segments(pos,:);

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

    r9714 r9725  
    2121
    2222h=1000;
    23 md.geometry.thickness=h*ones(md.numberofnodes,1);
     23md.geometry.thickness=h*ones(md.mesh.numberofvertices,1);
    2424md.geometry.bed=-md.materials.rho_ice/md.materials.rho_water*md.geometry.thickness;
    2525md.geometry.surface=md.geometry.bed+md.geometry.thickness;
    2626
    2727%Initial velocity and pressure
    28 md.initialization.vx=zeros(md.numberofnodes,1);
    29 md.initialization.vy=zeros(md.numberofnodes,1);
    30 md.initialization.vz=zeros(md.numberofnodes,1);
    31 md.initialization.pressure=zeros(md.numberofnodes,1);
     28md.initialization.vx=zeros(md.mesh.numberofvertices,1);
     29md.initialization.vy=zeros(md.mesh.numberofvertices,1);
     30md.initialization.vz=zeros(md.mesh.numberofvertices,1);
     31md.initialization.pressure=zeros(md.mesh.numberofvertices,1);
    3232
    3333%Materials
    34 md.initialization.temperature=(273-20)*ones(md.numberofnodes,1);
     34md.initialization.temperature=(273-20)*ones(md.mesh.numberofvertices,1);
    3535md.materials.rheology_B=paterson(md.initialization.temperature);
    36 md.materials.rheology_n=3*ones(md.numberofelements,1);
     36md.materials.rheology_n=3*ones(md.mesh.numberofelements,1);
    3737
    3838%Boundary conditions:
    39 md.diagnostic.spcvx=NaN*ones(md.numberofnodes,1);
    40 md.diagnostic.spcvy=NaN*ones(md.numberofnodes,1);
    41 md.diagnostic.spcvz=NaN*ones(md.numberofnodes,1);
     39md.diagnostic.spcvx=NaN*ones(md.mesh.numberofvertices,1);
     40md.diagnostic.spcvy=NaN*ones(md.mesh.numberofvertices,1);
     41md.diagnostic.spcvz=NaN*ones(md.mesh.numberofvertices,1);
    4242
    4343%constrain flanks to 0 normal velocity
    … …  
    5252
    5353%icefront
    54 nodeonicefront=zeros(md.numberofnodes,1);
     54nodeonicefront=zeros(md.mesh.numberofvertices,1);
    5555pos=find(md.y==ymax); nodeonicefront(pos)=1;
    5656pos=find(nodeonicefront(md.mesh.segments(:,1)) | nodeonicefront(md.mesh.segments(:,2))); diagnostic.icefront=md.mesh.segments(pos,:);

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

    r9720 r9725  
    1818
    1919h=1000;
    20 md.geometry.thickness=h*ones(md.numberofnodes,1);
     20md.geometry.thickness=h*ones(md.mesh.numberofvertices,1);
    2121md.geometry.bed=-md.materials.rho_ice/md.materials.rho_water*md.geometry.thickness;
    2222md.geometry.surface=md.geometry.bed+md.geometry.thickness;
    2323
    2424%Initial velocity and pressure
    25 md.initialization.vx=zeros(md.numberofnodes,1);
    26 md.initialization.vy=zeros(md.numberofnodes,1);
    27 md.initialization.vz=zeros(md.numberofnodes,1);
    28 md.initialization.pressure=zeros(md.numberofnodes,1);
     25md.initialization.vx=zeros(md.mesh.numberofvertices,1);
     26md.initialization.vy=zeros(md.mesh.numberofvertices,1);
     27md.initialization.vz=zeros(md.mesh.numberofvertices,1);
     28md.initialization.pressure=zeros(md.mesh.numberofvertices,1);
    2929
    3030%Materials
    31 md.initialization.temperature=(273-20)*ones(md.numberofnodes,1);
     31md.initialization.temperature=(273-20)*ones(md.mesh.numberofvertices,1);
    3232md.materials.rheology_B=paterson(md.initialization.temperature);
    33 md.materials.rheology_n=3*ones(md.numberofelements,1);
     33md.materials.rheology_n=3*ones(md.mesh.numberofelements,1);
    3434
    3535%Boundary conditions:
    36 md.diagnostic.spcvx=NaN*ones(md.numberofnodes,1);
    37 md.diagnostic.spcvy=NaN*ones(md.numberofnodes,1);
    38 md.diagnostic.spcvz=NaN*ones(md.numberofnodes,1);
     36md.diagnostic.spcvx=NaN*ones(md.mesh.numberofvertices,1);
     37md.diagnostic.spcvy=NaN*ones(md.mesh.numberofvertices,1);
     38md.diagnostic.spcvz=NaN*ones(md.mesh.numberofvertices,1);
    3939
    4040%constrain flanks to 0 normal velocity
    … …  
    4949
    5050%icefront
    51 nodeonicefront=zeros(md.numberofnodes,1);
     51nodeonicefront=zeros(md.mesh.numberofvertices,1);
    5252pos=find(md.y==ymax); nodeonicefront(pos)=1;
    5353pos=find(nodeonicefront(md.mesh.segments(:,1)) | nodeonicefront(md.mesh.segments(:,2))); diagnostic.icefront=md.mesh.segments(pos,:);
    … …  
    5656
    5757%partitioning
    58 md.qmu.numberofpartitions=md.numberofnodes;
     58md.qmu.numberofpartitions=md.mesh.numberofvertices;
    5959md=partitioner(md,'package','linear','npart',md.qmu.numberofpartitions);
    6060md.qmu.partition=md.qmu.partition-1;

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

    r9720 r9725  
    1818
    1919h=1000;
    20 md.geometry.thickness=h*ones(md.numberofnodes,1);
     20md.geometry.thickness=h*ones(md.mesh.numberofvertices,1);
    2121md.geometry.bed=-md.materials.rho_ice/md.materials.rho_water*md.geometry.thickness;
    2222md.geometry.surface=md.geometry.bed+md.geometry.thickness;
    2323
    2424%Initial velocity and pressure
    25 md.initialization.vx=zeros(md.numberofnodes,1);
    26 md.initialization.vy=zeros(md.numberofnodes,1);
    27 md.initialization.vz=zeros(md.numberofnodes,1);
    28 md.initialization.pressure=zeros(md.numberofnodes,1);
     25md.initialization.vx=zeros(md.mesh.numberofvertices,1);
     26md.initialization.vy=zeros(md.mesh.numberofvertices,1);
     27md.initialization.vz=zeros(md.mesh.numberofvertices,1);
     28md.initialization.pressure=zeros(md.mesh.numberofvertices,1);
    2929
    3030%Materials
    31 md.initialization.temperature=(273-20)*ones(md.numberofnodes,1);
     31md.initialization.temperature=(273-20)*ones(md.mesh.numberofvertices,1);
    3232md.materials.rheology_B=paterson(md.initialization.temperature);
    33 md.materials.rheology_n=3*ones(md.numberofelements,1);
     33md.materials.rheology_n=3*ones(md.mesh.numberofelements,1);
    3434
    3535%Boundary conditions:
    36 md.diagnostic.spcvx=NaN*ones(md.numberofnodes,1);
    37 md.diagnostic.spcvy=NaN*ones(md.numberofnodes,1);
    38 md.diagnostic.spcvz=NaN*ones(md.numberofnodes,1);
     36md.diagnostic.spcvx=NaN*ones(md.mesh.numberofvertices,1);
     37md.diagnostic.spcvy=NaN*ones(md.mesh.numberofvertices,1);
     38md.diagnostic.spcvz=NaN*ones(md.mesh.numberofvertices,1);
    3939
    4040%constrain flanks to 0 normal velocity
    … …  
    4949
    5050%icefront
    51 nodeonicefront=zeros(md.numberofnodes,1);
     51nodeonicefront=zeros(md.mesh.numberofvertices,1);
    5252pos=find(md.y==ymax); nodeonicefront(pos)=1;
    5353pos=find(nodeonicefront(md.mesh.segments(:,1)) | nodeonicefront(md.mesh.segments(:,2))); diagnostic.icefront=md.mesh.segments(pos,:);
    … …  
    5656
    5757%partitioning
    58 md.qmu.numberofpartitions=md.numberofnodes;
     58md.qmu.numberofpartitions=md.mesh.numberofvertices;
    5959md=partitioner(md,'package','linear','npart',md.qmu.numberofpartitions);
    6060md.qmu.partition=md.qmu.partition-1;

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

    r9720 r9725  
    1010
    1111%Set up transient
    12 smb = ones(md.numberofnodes,1)*3.6;
     12smb = ones(md.mesh.numberofvertices,1)*3.6;
    1313smb=[ smb smb*-1 ];
    1414

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

    r9720 r9725  
    1010
    1111%Set up transient
    12 smb = ones(md.numberofnodes,1)*3.6;
     12smb = ones(md.mesh.numberofvertices,1)*3.6;
    1313smb=[ smb smb*-1 ];
    1414

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

    r9720 r9725  
    1010
    1111%Set up transient
    12 smb = ones(md.numberofnodes,1)*3.6;
     12smb = ones(md.mesh.numberofvertices,1)*3.6;
    1313smb=[ smb smb*2 ];
    1414

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

    r9720 r9725  
    1010
    1111%Set up transient
    12 smb = ones(md.numberofnodes,1)*3.6;
     12smb = ones(md.mesh.numberofvertices,1)*3.6;
    1313smb=[ smb smb*2 ];
    1414

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

    r9720 r9725  
    1111
    1212%Set up transient
    13 smb = ones(md.numberofnodes,1)*3.6;
     13smb = ones(md.mesh.numberofvertices,1)*3.6;
    1414smb=[ smb smb*-1 ];
    1515

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

    r9720 r9725  
    1111
    1212%Set up transient
    13 smb = ones(md.numberofnodes,1)*3.6;
     13smb = ones(md.mesh.numberofvertices,1)*3.6;
    1414smb=[ smb smb*-1 ];
    1515

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

    r9720 r9725  
    1111
    1212%Set up transient
    13 smb = ones(md.numberofnodes,1)*3.6;
     13smb = ones(md.mesh.numberofvertices,1)*3.6;
    1414smb=[ smb smb*2 ];
    1515

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

    r9720 r9725  
    1111
    1212%Set up transient
    13 smb = ones(md.numberofnodes,1)*3.6;
     13smb = ones(md.mesh.numberofvertices,1)*3.6;
    1414smb=[ smb smb*2 ];
    1515

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

    r9703 r9725  
    77md.inversion.iscontrol=1;
    88md.inversion.control_parameters={'FrictionCoefficient'};
    9 md.inversion.min_parameters=1*ones(md.numberofnodes,1);
    10 md.inversion.max_parameters=200*ones(md.numberofnodes,1);
     9md.inversion.min_parameters=1*ones(md.mesh.numberofvertices,1);
     10md.inversion.max_parameters=200*ones(md.mesh.numberofvertices,1);
    1111md.inversion.nsteps=2;
    1212md.inversion.cost_functions=[103*ones(md.inversion.nsteps,1)  501*ones(md.inversion.nsteps,1)];
    13 md.inversion.cost_functions_coefficients=ones(md.numberofnodes,2); md.inversion.cost_functions_coefficients(:,2)=0*2*10^-7;
     13md.inversion.cost_functions_coefficients=ones(md.mesh.numberofvertices,2); md.inversion.cost_functions_coefficients(:,2)=0*2*10^-7;
    1414md.inversion.gradient_scaling=3*ones(md.inversion.nsteps,1);
    1515md.inversion.maxiter_per_step=2*ones(md.inversion.nsteps,1);

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

    r9703 r9725  
    77md.inversion.iscontrol=1;
    88md.inversion.control_parameters={'FrictionCoefficient'};
    9 md.inversion.min_parameters=1*ones(md.numberofnodes,1);
    10 md.inversion.max_parameters=200*ones(md.numberofnodes,1);
     9md.inversion.min_parameters=1*ones(md.mesh.numberofvertices,1);
     10md.inversion.max_parameters=200*ones(md.mesh.numberofvertices,1);
    1111md.inversion.nsteps=2;
    1212md.inversion.cost_functions=[103*ones(md.inversion.nsteps,1)  501*ones(md.inversion.nsteps,1)];
    13 md.inversion.cost_functions_coefficients=ones(md.numberofnodes,2); md.inversion.cost_functions_coefficients(:,2)=2*10^-7;
     13md.inversion.cost_functions_coefficients=ones(md.mesh.numberofvertices,2); md.inversion.cost_functions_coefficients(:,2)=2*10^-7;
    1414md.inversion.gradient_scaling=3*ones(md.inversion.nsteps,1);
    1515md.inversion.maxiter_per_step=2*ones(md.inversion.nsteps,1);

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

    r9703 r9725  
    88md.inversion.iscontrol=1;
    99md.inversion.control_parameters={'FrictionCoefficient'};
    10 md.inversion.min_parameters=1*ones(md.numberofnodes,1);
    11 md.inversion.max_parameters=200*ones(md.numberofnodes,1);
     10md.inversion.min_parameters=1*ones(md.mesh.numberofvertices,1);
     11md.inversion.max_parameters=200*ones(md.mesh.numberofvertices,1);
    1212md.inversion.nsteps=2;
    1313md.inversion.cost_functions=[103*ones(md.inversion.nsteps,1)  501*ones(md.inversion.nsteps,1)];
    14 md.inversion.cost_functions_coefficients=ones(md.numberofnodes,2); md.inversion.cost_functions_coefficients(:,2)=2*10^-7;
     14md.inversion.cost_functions_coefficients=ones(md.mesh.numberofvertices,2); md.inversion.cost_functions_coefficients(:,2)=2*10^-7;
    1515md.inversion.gradient_scaling=3*ones(md.inversion.nsteps,1);
    1616md.inversion.maxiter_per_step=2*ones(md.inversion.nsteps,1);

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

    r9703 r9725  
    88md.inversion.iscontrol=1;
    99md.inversion.control_parameters={'FrictionCoefficient'};
    10 md.inversion.min_parameters=1*ones(md.numberofnodes,1);
    11 md.inversion.max_parameters=200*ones(md.numberofnodes,1);
     10md.inversion.min_parameters=1*ones(md.mesh.numberofvertices,1);
     11md.inversion.max_parameters=200*ones(md.mesh.numberofvertices,1);
    1212md.inversion.nsteps=2;
    1313md.inversion.cost_functions=[103*ones(md.inversion.nsteps,1)  501*ones(md.inversion.nsteps,1)];
    14 md.inversion.cost_functions_coefficients=ones(md.numberofnodes,2); md.inversion.cost_functions_coefficients(:,2)=2*10^-7;
     14md.inversion.cost_functions_coefficients=ones(md.mesh.numberofvertices,2); md.inversion.cost_functions_coefficients(:,2)=2*10^-7;
    1515md.inversion.gradient_scaling=3*ones(md.inversion.nsteps,1);
    1616md.inversion.maxiter_per_step=2*ones(md.inversion.nsteps,1);

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

    r9703 r9725  
    88md.inversion.iscontrol=1;
    99md.inversion.control_parameters={'FrictionCoefficient'};
    10 md.inversion.min_parameters=1*ones(md.numberofnodes,1);
    11 md.inversion.max_parameters=200*ones(md.numberofnodes,1);
     10md.inversion.min_parameters=1*ones(md.mesh.numberofvertices,1);
     11md.inversion.max_parameters=200*ones(md.mesh.numberofvertices,1);
    1212md.inversion.nsteps=2;
    1313md.inversion.cost_functions=[102*ones(md.inversion.nsteps,1)  501*ones(md.inversion.nsteps,1)];
    14 md.inversion.cost_functions_coefficients=ones(md.numberofnodes,2); md.inversion.cost_functions_coefficients(:,2)=2*10^-7;
     14md.inversion.cost_functions_coefficients=ones(md.mesh.numberofvertices,2); md.inversion.cost_functions_coefficients(:,2)=2*10^-7;
    1515md.inversion.gradient_scaling=3*ones(md.inversion.nsteps,1);
    1616md.inversion.maxiter_per_step=2*ones(md.inversion.nsteps,1);

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

    r9703 r9725  
    88md.inversion.iscontrol=1;
    99md.inversion.control_parameters={'FrictionCoefficient'};
    10 md.inversion.min_parameters=1*ones(md.numberofnodes,1);
    11 md.inversion.max_parameters=200*ones(md.numberofnodes,1);
     10md.inversion.min_parameters=1*ones(md.mesh.numberofvertices,1);
     11md.inversion.max_parameters=200*ones(md.mesh.numberofvertices,1);
    1212md.inversion.nsteps=2;
    1313md.inversion.cost_functions=[102*ones(md.inversion.nsteps,1)  501*ones(md.inversion.nsteps,1)];
    14 md.inversion.cost_functions_coefficients=ones(md.numberofnodes,2); md.inversion.cost_functions_coefficients(:,2)=2*10^-7;
     14md.inversion.cost_functions_coefficients=ones(md.mesh.numberofvertices,2); md.inversion.cost_functions_coefficients(:,2)=2*10^-7;
    1515md.inversion.gradient_scaling=3*ones(md.inversion.nsteps,1);
    1616md.inversion.maxiter_per_step=2*ones(md.inversion.nsteps,1);

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

    r9703 r9725  
    88md.inversion.iscontrol=1;
    99md.inversion.control_parameters={'FrictionCoefficient'};
    10 md.inversion.min_parameters=1*ones(md.numberofnodes,1);
    11 md.inversion.max_parameters=200*ones(md.numberofnodes,1);
     10md.inversion.min_parameters=1*ones(md.mesh.numberofvertices,1);
     11md.inversion.max_parameters=200*ones(md.mesh.numberofvertices,1);
    1212md.inversion.nsteps=2;
    1313md.inversion.cost_functions=[104*ones(md.inversion.nsteps,1)  501*ones(md.inversion.nsteps,1)];
    14 md.inversion.cost_functions_coefficients=ones(md.numberofnodes,2); md.inversion.cost_functions_coefficients(:,2)=2*10^-7;
     14md.inversion.cost_functions_coefficients=ones(md.mesh.numberofvertices,2); md.inversion.cost_functions_coefficients(:,2)=2*10^-7;
    1515md.inversion.gradient_scaling=3*ones(md.inversion.nsteps,1);
    1616md.inversion.maxiter_per_step=2*ones(md.inversion.nsteps,1);

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

    r9703 r9725  
    88md.inversion.iscontrol=1;
    99md.inversion.control_parameters={'FrictionCoefficient'};
    10 md.inversion.min_parameters=1*ones(md.numberofnodes,1);
    11 md.inversion.max_parameters=200*ones(md.numberofnodes,1);
     10md.inversion.min_parameters=1*ones(md.mesh.numberofvertices,1);
     11md.inversion.max_parameters=200*ones(md.mesh.numberofvertices,1);
    1212md.inversion.nsteps=2;
    1313md.inversion.cost_functions=[104*ones(md.inversion.nsteps,1)  501*ones(md.inversion.nsteps,1)];
    14 md.inversion.cost_functions_coefficients=ones(md.numberofnodes,2); md.inversion.cost_functions_coefficients(:,2)=2*10^-7;
     14md.inversion.cost_functions_coefficients=ones(md.mesh.numberofvertices,2); md.inversion.cost_functions_coefficients(:,2)=2*10^-7;
    1515md.inversion.gradient_scaling=3*ones(md.inversion.nsteps,1);
    1616md.inversion.maxiter_per_step=2*ones(md.inversion.nsteps,1);

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

    r9703 r9725  
    66
    77%partitioning
    8 md.qmu.numberofpartitions=md.numberofnodes;
     8md.qmu.numberofpartitions=md.mesh.numberofvertices;
    99md=partitioner(md,'package','linear','npart',md.qmu.numberofpartitions);
    1010md.qmu.partition=md.qmu.partition-1;

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

    r9703 r9725  
    66
    77%partitioning
    8 md.qmu.numberofpartitions=md.numberofnodes;
     8md.qmu.numberofpartitions=md.mesh.numberofvertices;
    99md=partitioner(md,'package','linear','npart',md.qmu.numberofpartitions);
    1010md.qmu.partition=md.qmu.partition-1;

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

    r9703 r9725  
    88
    99%constrain all velocities to 1 m/yr, in the y-direction
    10 md.diagnostic.spcvx=zeros(md.numberofnodes,1);
    11 md.diagnostic.spcvy=ones(md.numberofnodes,1);
    12 md.diagnostic.spcvz=zeros(md.numberofnodes,1);
     10md.diagnostic.spcvx=zeros(md.mesh.numberofvertices,1);
     11md.diagnostic.spcvy=ones(md.mesh.numberofvertices,1);
     12md.diagnostic.spcvz=zeros(md.mesh.numberofvertices,1);
    1313
    1414%Dakota options

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

    r9703 r9725  
    88md.inversion.iscontrol=1;
    99md.inversion.control_parameters={'FrictionCoefficient'};
    10 md.inversion.min_parameters=1*ones(md.numberofnodes,1);
    11 md.inversion.max_parameters=200*ones(md.numberofnodes,1);
     10md.inversion.min_parameters=1*ones(md.mesh.numberofvertices,1);
     11md.inversion.max_parameters=200*ones(md.mesh.numberofvertices,1);
    1212md.inversion.nsteps=2;
    1313md.inversion.cost_functions=[103*ones(md.inversion.nsteps,1)  501*ones(md.inversion.nsteps,1)];
    14 md.inversion.cost_functions_coefficients=ones(md.numberofnodes,2); md.inversion.cost_functions_coefficients(:,2)=2*10^-7;
     14md.inversion.cost_functions_coefficients=ones(md.mesh.numberofvertices,2); md.inversion.cost_functions_coefficients(:,2)=2*10^-7;
    1515md.inversion.gradient_scaling=3*ones(md.inversion.nsteps,1);
    1616md.inversion.maxiter_per_step=2*ones(md.inversion.nsteps,1);

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

    r9703 r9725  
    88md.inversion.iscontrol=1;
    99md.inversion.control_parameters={'FrictionCoefficient'};
    10 md.inversion.min_parameters=1*ones(md.numberofnodes,1);
    11 md.inversion.max_parameters=200*ones(md.numberofnodes,1);
     10md.inversion.min_parameters=1*ones(md.mesh.numberofvertices,1);
     11md.inversion.max_parameters=200*ones(md.mesh.numberofvertices,1);
    1212md.inversion.nsteps=2;
    1313md.inversion.cost_functions=[103*ones(md.inversion.nsteps,1)  501*ones(md.inversion.nsteps,1)];
    14 md.inversion.cost_functions_coefficients=ones(md.numberofnodes,2); md.inversion.cost_functions_coefficients(:,2)=2*10^-7;
     14md.inversion.cost_functions_coefficients=ones(md.mesh.numberofvertices,2); md.inversion.cost_functions_coefficients(:,2)=2*10^-7;
    1515md.inversion.gradient_scaling=3*ones(md.inversion.nsteps,1);
    1616md.inversion.maxiter_per_step=2*ones(md.inversion.nsteps,1);

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

    r9703 r9725  
    88md.inversion.iscontrol=1;
    99md.inversion.control_parameters={'FrictionCoefficient'};
    10 md.inversion.min_parameters=1*ones(md.numberofnodes,1);
    11 md.inversion.max_parameters=200*ones(md.numberofnodes,1);
     10md.inversion.min_parameters=1*ones(md.mesh.numberofvertices,1);
     11md.inversion.max_parameters=200*ones(md.mesh.numberofvertices,1);
    1212md.inversion.nsteps=2;
    1313md.inversion.cost_functions=[102*ones(md.inversion.nsteps,1)  501*ones(md.inversion.nsteps,1)];
    14 md.inversion.cost_functions_coefficients=ones(md.numberofnodes,2); md.inversion.cost_functions_coefficients(:,2)=2*10^-7;
     14md.inversion.cost_functions_coefficients=ones(md.mesh.numberofvertices,2); md.inversion.cost_functions_coefficients(:,2)=2*10^-7;
    1515md.inversion.gradient_scaling=3*ones(md.inversion.nsteps,1);
    1616md.inversion.maxiter_per_step=2*ones(md.inversion.nsteps,1);

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

    r9703 r9725  
    88md.inversion.iscontrol=1;
    99md.inversion.control_parameters={'FrictionCoefficient'};
    10 md.inversion.min_parameters=1*ones(md.numberofnodes,1);
    11 md.inversion.max_parameters=200*ones(md.numberofnodes,1);
     10md.inversion.min_parameters=1*ones(md.mesh.numberofvertices,1);
     11md.inversion.max_parameters=200*ones(md.mesh.numberofvertices,1);
    1212md.inversion.nsteps=2;
    1313md.inversion.cost_functions=[102*ones(md.inversion.nsteps,1)  501*ones(md.inversion.nsteps,1)];
    14 md.inversion.cost_functions_coefficients=ones(md.numberofnodes,2); md.inversion.cost_functions_coefficients(:,2)=2*10^-7;
     14md.inversion.cost_functions_coefficients=ones(md.mesh.numberofvertices,2); md.inversion.cost_functions_coefficients(:,2)=2*10^-7;
    1515md.inversion.gradient_scaling=3*ones(md.inversion.nsteps,1);
    1616md.inversion.maxiter_per_step=2*ones(md.inversion.nsteps,1);

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

    r9703 r9725  
    1111md.qmu.partition=md.qmu.partition-1;
    1212
    13 vector=(1:1:md.numberofnodes)';
     13vector=(1:1:md.mesh.numberofvertices)';
    1414vector_on_partition=AreaAverageOntoPartition(md,vector);
    1515vector_on_nodes=vector_on_partition(md.qmu.partition+1);

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

    r9691 r9725  
    1313yelem=md.y(md.elements)*[1;1;1]/3;
    1414rad=sqrt((xelem).*xelem+(yelem).*yelem);
    15 flags=zeros(md.numberofelements,1);
     15flags=zeros(md.mesh.numberofelements,1);
    1616pos=find(rad>=(radius-shelfextent));
    1717flags(pos)=1;
    18 flags2=zeros(md.numberofelements,1);
     18flags2=zeros(md.mesh.numberofelements,1);
    1919md=setmask(md,flags,flags2);
    2020%}}}
    … …  
    4444%grounding line:
    4545md.groundingline.migration='AgressiveMigration';
    46 md=solve(md,GroundinglineMigration2DSolutionEnum);
    47 element_on_iceshelf_agressive=PatchToVec(md.results.GroundinglineMigration2DSolution.MaskElementonfloatingice);
     46md=solve(md,GroundinglineMigration2dSolutionEnum);
     47element_on_iceshelf_agressive=PatchToVec(md.results.GroundinglineMigration2dSolution.MaskElementonfloatingice);
    4848
    4949md.groundingline.migration='SoftMigration';
    50 md=solve(md,GroundinglineMigration2DSolutionEnum);
    51 element_on_iceshelf_soft=PatchToVec(md.results.GroundinglineMigration2DSolution.MaskElementonfloatingice);
     50md=solve(md,GroundinglineMigration2dSolutionEnum);
     51element_on_iceshelf_soft=PatchToVec(md.results.GroundinglineMigration2dSolution.MaskElementonfloatingice);
    5252
    5353%Fields and tolerances to track changes

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

    r9703 r9725  
    1313md.inversion.iscontrol=1;
    1414md.inversion.control_parameters={'MaterialsRheologyBbar'};
    15 md.inversion.min_parameters=10^6*ones(md.numberofnodes,1);
    16 md.inversion.max_parameters=2*10^9*ones(md.numberofnodes,1);
     15md.inversion.min_parameters=10^6*ones(md.mesh.numberofvertices,1);
     16md.inversion.max_parameters=2*10^9*ones(md.mesh.numberofvertices,1);
    1717md.inversion.nsteps=2;
    1818md.inversion.cost_functions=101*ones(md.inversion.nsteps,1);
    19 md.inversion.cost_functions_coefficients=ones(md.numberofnodes,1);
     19md.inversion.cost_functions_coefficients=ones(md.mesh.numberofvertices,1);
    2020md.inversion.gradient_scaling=10^8*ones(md.inversion.nsteps,1);
    2121md.inversion.maxiter_per_step=2*ones(md.inversion.nsteps,1);

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

    r9703 r9725  
    1313md.inversion.iscontrol=1;
    1414md.inversion.control_parameters={'MaterialsRheologyBbar'};
    15 md.inversion.min_parameters=10^6*ones(md.numberofnodes,1);
    16 md.inversion.max_parameters=2*10^9*ones(md.numberofnodes,1);
     15md.inversion.min_parameters=10^6*ones(md.mesh.numberofvertices,1);
     16md.inversion.max_parameters=2*10^9*ones(md.mesh.numberofvertices,1);
    1717md.inversion.nsteps=2;
    1818md.inversion.cost_functions=101*ones(md.inversion.nsteps,1);
    19 md.inversion.cost_functions_coefficients=ones(md.numberofnodes,1);
     19md.inversion.cost_functions_coefficients=ones(md.mesh.numberofvertices,1);
    2020md.inversion.gradient_scaling=10^8*ones(md.inversion.nsteps,1);
    2121md.inversion.maxiter_per_step=2*ones(md.inversion.nsteps,1);

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

    r9703 r9725  
    88md.inversion.iscontrol=1;
    99md.inversion.control_parameters={'FrictionCoefficient'};
    10 md.inversion.min_parameters=1*ones(md.numberofnodes,1);
    11 md.inversion.max_parameters=200*ones(md.numberofnodes,1);
     10md.inversion.min_parameters=1*ones(md.mesh.numberofvertices,1);
     11md.inversion.max_parameters=200*ones(md.mesh.numberofvertices,1);
    1212md.inversion.nsteps=2;
    1313md.inversion.cost_functions=[103*ones(md.inversion.nsteps,1)  501*ones(md.inversion.nsteps,1)];
    14 md.inversion.cost_functions_coefficients=ones(md.numberofnodes,2); md.inversion.cost_functions_coefficients(:,2)=2*10^-7;
     14md.inversion.cost_functions_coefficients=ones(md.mesh.numberofvertices,2); md.inversion.cost_functions_coefficients(:,2)=2*10^-7;
    1515md.inversion.gradient_scaling=3*ones(md.inversion.nsteps,1);
    1616md.inversion.maxiter_per_step=2*ones(md.inversion.nsteps,1);

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

    r9703 r9725  
    88md.inversion.iscontrol=1;
    99md.inversion.control_parameters={'FrictionCoefficient'};
    10 md.inversion.min_parameters=1*ones(md.numberofnodes,1);
    11 md.inversion.max_parameters=200*ones(md.numberofnodes,1);
     10md.inversion.min_parameters=1*ones(md.mesh.numberofvertices,1);
     11md.inversion.max_parameters=200*ones(md.mesh.numberofvertices,1);
    1212md.inversion.nsteps=2;
    1313md.inversion.cost_functions=[103*ones(md.inversion.nsteps,1)  501*ones(md.inversion.nsteps,1)];
    14 md.inversion.cost_functions_coefficients=ones(md.numberofnodes,2); md.inversion.cost_functions_coefficients(:,2)=2*10^-7;
     14md.inversion.cost_functions_coefficients=ones(md.mesh.numberofvertices,2); md.inversion.cost_functions_coefficients(:,2)=2*10^-7;
    1515md.inversion.gradient_scaling=3*ones(md.inversion.nsteps,1);
    1616md.inversion.maxiter_per_step=2*ones(md.inversion.nsteps,1);

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

    r9703 r9725  
    88md.inversion.iscontrol=1;
    99md.inversion.control_parameters={'FrictionCoefficient'};
    10 md.inversion.min_parameters=1*ones(md.numberofnodes,1);
    11 md.inversion.max_parameters=200*ones(md.numberofnodes,1);
     10md.inversion.min_parameters=1*ones(md.mesh.numberofvertices,1);
     11md.inversion.max_parameters=200*ones(md.mesh.numberofvertices,1);
    1212md.inversion.nsteps=2;
    1313md.inversion.cost_functions=[103*ones(md.inversion.nsteps,1)  501*ones(md.inversion.nsteps,1)];
    14 md.inversion.cost_functions_coefficients=ones(md.numberofnodes,2); md.inversion.cost_functions_coefficients(:,2)=2*10^-7;
     14md.inversion.cost_functions_coefficients=ones(md.mesh.numberofvertices,2); md.inversion.cost_functions_coefficients(:,2)=2*10^-7;
    1515md.inversion.gradient_scaling=3*ones(md.inversion.nsteps,1);
    1616md.inversion.maxiter_per_step=2*ones(md.inversion.nsteps,1);

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

    r9703 r9725  
    88md.inversion.iscontrol=1;
    99md.inversion.control_parameters={'FrictionCoefficient'};
    10 md.inversion.min_parameters=1*ones(md.numberofnodes,1);
    11 md.inversion.max_parameters=200*ones(md.numberofnodes,1);
     10md.inversion.min_parameters=1*ones(md.mesh.numberofvertices,1);
     11md.inversion.max_parameters=200*ones(md.mesh.numberofvertices,1);
    1212md.inversion.nsteps=2;
    1313md.inversion.cost_functions=[103*ones(md.inversion.nsteps,1)  501*ones(md.inversion.nsteps,1)];
    14 md.inversion.cost_functions_coefficients=ones(md.numberofnodes,2); md.inversion.cost_functions_coefficients(:,2)=2*10^-7;
     14md.inversion.cost_functions_coefficients=ones(md.mesh.numberofvertices,2); md.inversion.cost_functions_coefficients(:,2)=2*10^-7;
    1515md.inversion.gradient_scaling=3*ones(md.inversion.nsteps,1);
    1616md.inversion.maxiter_per_step=2*ones(md.inversion.nsteps,1);

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

    r9714 r9725  
    2727
    2828%refine existing mesh 3
    29 hVertices=NaN*ones(md.numberofnodes,1);
     29hVertices=NaN*ones(md.mesh.numberofvertices,1);
    3030hVertices(find(md.mesh.vertexonboundary))=500;
    3131md2=bamg(md,'metric',md.miscellaneous.dummy,'hmin',1000,'hmax',20000,'gradation',3,'geometricalmetric',1,'anisomax',1,'hVertices',hVertices);

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

    r9703 r9725  
    1010md.inversion.control_parameters={'BalancethicknessThickeningRate'};
    1111md.inversion.thickness_obs=md.geometry.thickness;
    12 md.inversion.min_parameters=-50*ones(md.numberofnodes,1);
    13 md.inversion.max_parameters=50*ones(md.numberofnodes,1);
     12md.inversion.min_parameters=-50*ones(md.mesh.numberofvertices,1);
     13md.inversion.max_parameters=50*ones(md.mesh.numberofvertices,1);
    1414md.inversion.cost_functions=201*ones(md.inversion.nsteps,1);
    15 md.inversion.cost_functions_coefficients=ones(md.numberofnodes,1);
     15md.inversion.cost_functions_coefficients=ones(md.mesh.numberofvertices,1);
    1616md.inversion.gradient_scaling=10/md.constants.yts*ones(md.inversion.nsteps,1);
    1717md.inversion.maxiter_per_step=4*ones(md.inversion.nsteps,1);

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

    r9703 r9725  
    1010md.inversion.control_parameters={'BalancethicknessThickeningRate'};
    1111md.inversion.thickness_obs=md.geometry.thickness;
    12 md.inversion.min_parameters=-50*ones(md.numberofnodes,1);
    13 md.inversion.max_parameters=50*ones(md.numberofnodes,1);
     12md.inversion.min_parameters=-50*ones(md.mesh.numberofvertices,1);
     13md.inversion.max_parameters=50*ones(md.mesh.numberofvertices,1);
    1414md.inversion.cost_functions=201*ones(md.inversion.nsteps,1);
    15 md.inversion.cost_functions_coefficients=ones(md.numberofnodes,1);
     15md.inversion.cost_functions_coefficients=ones(md.mesh.numberofvertices,1);
    1616md.inversion.gradient_scaling=10/md.constants.yts*ones(md.inversion.nsteps,1);
    1717md.inversion.maxiter_per_step=4*ones(md.inversion.nsteps,1);

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

    r9703 r9725  
    1111md.inversion.control_parameters={'BalancethicknessThickeningRate'};
    1212md.inversion.thickness_obs=md.geometry.thickness;
    13 md.inversion.min_parameters=-50*ones(md.numberofnodes,1);
    14 md.inversion.max_parameters=50*ones(md.numberofnodes,1);
     13md.inversion.min_parameters=-50*ones(md.mesh.numberofvertices,1);
     14md.inversion.max_parameters=50*ones(md.mesh.numberofvertices,1);
    1515md.inversion.cost_functions=201*ones(md.inversion.nsteps,1);
    16 md.inversion.cost_functions_coefficients=ones(md.numberofnodes,1);
     16md.inversion.cost_functions_coefficients=ones(md.mesh.numberofvertices,1);
    1717md.inversion.gradient_scaling=10/md.constants.yts*ones(md.inversion.nsteps,1);
    1818md.inversion.maxiter_per_step=4*ones(md.inversion.nsteps,1);

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

    r9703 r9725  
    1111md.inversion.control_parameters={'BalancethicknessThickeningRate'};
    1212md.inversion.thickness_obs=md.geometry.thickness;
    13 md.inversion.min_parameters=-50*ones(md.numberofnodes,1);
    14 md.inversion.max_parameters=50*ones(md.numberofnodes,1);
     13md.inversion.min_parameters=-50*ones(md.mesh.numberofvertices,1);
     14md.inversion.max_parameters=50*ones(md.mesh.numberofvertices,1);
    1515md.inversion.cost_functions=201*ones(md.inversion.nsteps,1);
    16 md.inversion.cost_functions_coefficients=ones(md.numberofnodes,1);
     16md.inversion.cost_functions_coefficients=ones(md.mesh.numberofvertices,1);
    1717md.inversion.gradient_scaling=10/md.constants.yts*ones(md.inversion.nsteps,1);
    1818md.inversion.maxiter_per_step=4*ones(md.inversion.nsteps,1);

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

    r9714 r9725  
    1818md.balancethickness.stabilization=1;
    1919md.inversion.gradient_scaling=[10/md.constants.yts*ones(md.inversion.nsteps,1) 10/md.constants.yts*ones(md.inversion.nsteps,1)];
    20 md.inversion.min_parameters=[-2000*ones(md.numberofnodes,1) -2000*ones(md.numberofnodes,1)];
    21 md.inversion.max_parameters=[+2000*ones(md.numberofnodes,1) +2000*ones(md.numberofnodes,1)];
     20md.inversion.min_parameters=[-2000*ones(md.mesh.numberofvertices,1) -2000*ones(md.mesh.numberofvertices,1)];
     21md.inversion.max_parameters=[+2000*ones(md.mesh.numberofvertices,1) +2000*ones(md.mesh.numberofvertices,1)];
    2222md.inversion.cost_functions=201*ones(md.inversion.nsteps,1);
    23 md.inversion.cost_functions_coefficients=ones(md.numberofnodes,1);
     23md.inversion.cost_functions_coefficients=ones(md.mesh.numberofvertices,1);
    2424md.inversion.maxiter_per_step=4*ones(md.inversion.nsteps,1);
    2525md.inversion.step_threshold=0.99*ones(md.inversion.nsteps,1);

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

    r9714 r9725  
    1818md.balancethickness.stabilization=1;
    1919md.inversion.gradient_scaling=[10/md.constants.yts*ones(md.inversion.nsteps,1) 10/md.constants.yts*ones(md.inversion.nsteps,1)];
    20 md.inversion.min_parameters=[-2000*ones(md.numberofnodes,1) -2000*ones(md.numberofnodes,1)];
    21 md.inversion.max_parameters=[+2000*ones(md.numberofnodes,1) +2000*ones(md.numberofnodes,1)];
     20md.inversion.min_parameters=[-2000*ones(md.mesh.numberofvertices,1) -2000*ones(md.mesh.numberofvertices,1)];
     21md.inversion.max_parameters=[+2000*ones(md.mesh.numberofvertices,1) +2000*ones(md.mesh.numberofvertices,1)];
    2222md.inversion.cost_functions=201*ones(md.inversion.nsteps,1);
    23 md.inversion.cost_functions_coefficients=ones(md.numberofnodes,1);
     23md.inversion.cost_functions_coefficients=ones(md.mesh.numberofvertices,1);
    2424md.inversion.maxiter_per_step=4*ones(md.inversion.nsteps,1);
    2525md.inversion.step_threshold=0.99*ones(md.inversion.nsteps,1);

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

    r9714 r9725  
    1111
    1212%Materials
    13 md.initialization.temperature=(273-20)*ones(md.numberofnodes,1);
     13md.initialization.temperature=(273-20)*ones(md.mesh.numberofvertices,1);
    1414md.materials.rheology_B=paterson(md.initialization.temperature);
    15 md.materials.rheology_n=3*ones(md.numberofelements,1);
     15md.materials.rheology_n=3*ones(md.mesh.numberofelements,1);
    1616
    1717%Friction
    1818pos=find(md.mask.elementonfloatingice);
    19 md.friction.coefficient=50*ones(md.numberofnodes,1);
     19md.friction.coefficient=50*ones(md.mesh.numberofvertices,1);
    2020md.friction.coefficient(md.elements(pos,:))=0;
    21 md.friction.p=ones(md.numberofelements,1);
    22 md.friction.q=ones(md.numberofelements,1);
     21md.friction.p=ones(md.mesh.numberofelements,1);
     22md.friction.q=ones(md.mesh.numberofelements,1);
    2323
    2424%Ice shelf melting and surface mass balance
    25 md.basalforcings.melting_rate=zeros(md.numberofnodes,1);
    26 pos=zeros(md.numberofnodes,1);
     25md.basalforcings.melting_rate=zeros(md.mesh.numberofvertices,1);
     26pos=zeros(md.mesh.numberofvertices,1);
    2727pos(md.elements(find(md.mask.elementonfloatingice),:))=1;
    2828md.basalforcings.melting_rate(find(pos))=10;
    29 md.surfaceforcings.mass_balance=15*ones(md.numberofnodes,1);
     29md.surfaceforcings.mass_balance=15*ones(md.mesh.numberofvertices,1);
    3030
    3131%Numerical parameters

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

    r9691 r9725  
    77
    88disp('      creating drag');
    9 md.friction.coefficient=200*ones(md.numberofnodes,1); %q=1.
     9md.friction.coefficient=200*ones(md.mesh.numberofvertices,1); %q=1.
    1010%Take care of iceshelves: no basal drag
    1111pos=find(md.mask.elementonfloatingice);
    1212md.friction.coefficient(md.elements(pos,:))=0;
    13 md.friction.p=ones(md.numberofelements,1);
    14 md.friction.q=ones(md.numberofelements,1);
     13md.friction.p=ones(md.mesh.numberofelements,1);
     14md.friction.q=ones(md.mesh.numberofelements,1);
    1515
    1616disp('      creating flow law paramter');
    17 md.materials.rheology_B=6.8067*10^7*ones(md.numberofnodes,1);
    18 md.materials.rheology_n=3*ones(md.numberofelements,1);
     17md.materials.rheology_B=6.8067*10^7*ones(md.mesh.numberofvertices,1);
     18md.materials.rheology_n=3*ones(md.mesh.numberofelements,1);
    1919
    2020disp('      boundary conditions for diagnostic model');

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

    r9691 r9725  
    77
    88disp('      creating drag');
    9 md.friction.coefficient=200*ones(md.numberofnodes,1); %q=1.
     9md.friction.coefficient=200*ones(md.mesh.numberofvertices,1); %q=1.
    1010%Take care of iceshelves: no basal drag
    1111pos=find(md.mask.elementonfloatingice);
    1212md.friction.coefficient(md.elements(pos,:))=0;
    13 md.friction.p=ones(md.numberofelements,1);
    14 md.friction.q=ones(md.numberofelements,1);
     13md.friction.p=ones(md.mesh.numberofelements,1);
     14md.friction.q=ones(md.mesh.numberofelements,1);
    1515
    1616disp('      creating flow law paramter');
    17 md.materials.rheology_B=6.8067*10^7*ones(md.numberofnodes,1);
    18 md.materials.rheology_n=3*ones(md.numberofelements,1);
     17md.materials.rheology_B=6.8067*10^7*ones(md.mesh.numberofvertices,1);
     18md.materials.rheology_n=3*ones(md.mesh.numberofelements,1);
    1919
    2020disp('      boundary conditions for diagnostic model');

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

    r9691 r9725  
    1212pos=find(md.mask.elementonfloatingice);
    1313md.friction.coefficient(md.elements(pos,:))=0;
    14 md.friction.p=ones(md.numberofelements,1);
    15 md.friction.q=zeros(md.numberofelements,1);
     14md.friction.p=ones(md.mesh.numberofelements,1);
     15md.friction.q=zeros(md.mesh.numberofelements,1);
    1616
    1717disp('      creating flow law paramter');
    18 md.materials.rheology_B=6.8067*10^7*ones(md.numberofnodes,1);
    19 md.materials.rheology_n=3*ones(md.numberofelements,1);
     18md.materials.rheology_B=6.8067*10^7*ones(md.mesh.numberofvertices,1);
     19md.materials.rheology_n=3*ones(md.mesh.numberofelements,1);
    2020
    2121disp('      boundary conditions for diagnostic model: ');

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

    r9691 r9725  
    1111pos=find(md.mask.elementonfloatingice);
    1212md.friction.coefficient(md.elements(pos,:))=0;
    13 md.friction.p=ones(md.numberofelements,1);
    14 md.friction.q=zeros(md.numberofelements,1);
     13md.friction.p=ones(md.mesh.numberofelements,1);
     14md.friction.q=zeros(md.mesh.numberofelements,1);
    1515
    1616disp('      creating flow law paramter');
    17 md.materials.rheology_B=6.8067*10^7*ones(md.numberofnodes,1);
    18 md.materials.rheology_n=3*ones(md.numberofelements,1);
     17md.materials.rheology_B=6.8067*10^7*ones(md.mesh.numberofvertices,1);
     18md.materials.rheology_n=3*ones(md.mesh.numberofelements,1);
    1919
    2020disp('      boundary conditions for diagnostic model: ');

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

    r9691 r9725  
    44data=load('../Data/ISMIPE.data','-mat');
    55data=data.data;
    6 md.geometry.surface=zeros(md.numberofnodes,1);
    7 md.geometry.bed=zeros(md.numberofnodes,1);
    8 for i=1:md.numberofnodes
     6md.geometry.surface=zeros(md.mesh.numberofvertices,1);
     7md.geometry.bed=zeros(md.mesh.numberofvertices,1);
     8for i=1:md.mesh.numberofvertices
    99        y=md.y(i);
    1010        point1=floor(y/100)+1;
    … …  
    1919
    2020disp('      creating drag');
    21 md.friction.coefficient=zeros(md.numberofnodes,1);
    22 md.friction.p=ones(md.numberofelements,1);
    23 md.friction.q=ones(md.numberofelements,1);
     21md.friction.coefficient=zeros(md.mesh.numberofvertices,1);
     22md.friction.p=ones(md.mesh.numberofelements,1);
     23md.friction.q=ones(md.mesh.numberofelements,1);
    2424
    2525disp('      creating flow law paramter');
    26 md.materials.rheology_B=6.8067*10^7*ones(md.numberofnodes,1);
    27 md.materials.rheology_n=3*ones(md.numberofelements,1);
     26md.materials.rheology_B=6.8067*10^7*ones(md.mesh.numberofvertices,1);
     27md.materials.rheology_n=3*ones(md.mesh.numberofelements,1);
    2828
    2929disp('      boundary conditions for diagnostic model: ');

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

    r9705 r9725  
    99
    1010disp('      creating drag');
    11 md.friction.coefficient=sqrt(md.constants.yts/(2.140373*10^-7*1000))*ones(md.numberofnodes,1);
    12 md.friction.p=ones(md.numberofelements,1);
    13 md.friction.q=zeros(md.numberofelements,1);
     11md.friction.coefficient=sqrt(md.constants.yts/(2.140373*10^-7*1000))*ones(md.mesh.numberofvertices,1);
     12md.friction.p=ones(md.mesh.numberofelements,1);
     13md.friction.q=zeros(md.mesh.numberofelements,1);
    1414
    1515disp('      creating flow law paramter');
    16 md.materials.rheology_B=1.4734*10^14*ones(md.numberofnodes,1);
    17 md.materials.rheology_n=1*ones(md.numberofelements,1);
     16md.materials.rheology_B=1.4734*10^14*ones(md.mesh.numberofvertices,1);
     17md.materials.rheology_n=1*ones(md.mesh.numberofelements,1);
    1818md.materials.rheology_law='None';
    1919
    … …  
    2121%Create node on boundary fist (because we cannot use mesh)
    2222md=SetIceSheetBC(md);
    23 md.diagnostic.spcvx=100*ones(md.numberofnodes,1);
    24 md.initialization.vx=zeros(md.numberofnodes,1);
    25 md.initialization.vy=zeros(md.numberofnodes,1);
    26 md.initialization.vz=zeros(md.numberofnodes,1);
    27 md.initialization.vel=zeros(md.numberofnodes,1);
    28 md.initialization.pressure=zeros(md.numberofnodes,1);
    29 md.initialization.temperature=255*ones(md.numberofnodes,1);
     23md.diagnostic.spcvx=100*ones(md.mesh.numberofvertices,1);
     24md.initialization.vx=zeros(md.mesh.numberofvertices,1);
     25md.initialization.vy=zeros(md.mesh.numberofvertices,1);
     26md.initialization.vz=zeros(md.mesh.numberofvertices,1);
     27md.initialization.vel=zeros(md.mesh.numberofvertices,1);
     28md.initialization.pressure=zeros(md.mesh.numberofvertices,1);
     29md.initialization.temperature=255*ones(md.mesh.numberofvertices,1);
    3030pos=find(md.x==min(md.x) | md.x==max(md.x) | md.y==min(md.y) | md.y==max(md.y));
    31 md.balancethickness.spcthickness=NaN*ones(md.numberofnodes,1);
     31md.balancethickness.spcthickness=NaN*ones(md.mesh.numberofvertices,1);
    3232md.balancethickness.spcthickness(pos)=md.geometry.thickness(pos);
    33 md.prognostic.spcthickness=NaN*ones(md.numberofnodes,1);
     33md.prognostic.spcthickness=NaN*ones(md.mesh.numberofvertices,1);
    3434md.prognostic.spcthickness(pos)=md.geometry.thickness(pos);
    35 md.thermal.spctemperature=255*ones(md.numberofnodes,1);
    36 md.basalforcings.geothermalflux=0.4*ones(md.numberofnodes,1);
     35md.thermal.spctemperature=255*ones(md.mesh.numberofvertices,1);
     36md.basalforcings.geothermalflux=0.4*ones(md.mesh.numberofvertices,1);
    3737
    3838%Parallel options

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

    r9702 r9725  
    1111md.initialization.vx=md.inversion.vx_obs;
    1212md.initialization.vy=md.inversion.vy_obs;
    13 md.initialization.vz=zeros(md.numberofnodes,1);
    14 md.initialization.pressure=zeros(md.numberofnodes,1);
     13md.initialization.vz=zeros(md.mesh.numberofvertices,1);
     14md.initialization.pressure=zeros(md.mesh.numberofvertices,1);
    1515
    1616%Materials
    17 md.initialization.temperature=(273-20)*ones(md.numberofnodes,1);
     17md.initialization.temperature=(273-20)*ones(md.mesh.numberofvertices,1);
    1818md.materials.rheology_B=paterson(md.initialization.temperature);
    19 md.materials.rheology_n=3*ones(md.numberofelements,1);
     19md.materials.rheology_n=3*ones(md.mesh.numberofelements,1);
    2020md.initialization.temperature=md.initialization.temperature;
    2121
    2222%Friction
    2323pos=find(md.mask.elementonfloatingice);
    24 md.friction.coefficient=50*ones(md.numberofnodes,1);
     24md.friction.coefficient=50*ones(md.mesh.numberofvertices,1);
    2525md.friction.coefficient(md.elements(pos,:))=0;
    26 md.friction.p=ones(md.numberofelements,1);
    27 md.friction.q=ones(md.numberofelements,1);
     26md.friction.p=ones(md.mesh.numberofelements,1);
     27md.friction.q=ones(md.mesh.numberofelements,1);
    2828
    2929%Numerical parameters

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

    r9691 r9725  
    11%Ok, start defining model parameters here
    22disp('      creating thickness');
    3 md.geometry.thickness=10*ones(md.numberofnodes,1);
    4 md.geometry.bed=zeros(md.numberofnodes,1);
     3md.geometry.thickness=10*ones(md.mesh.numberofvertices,1);
     4md.geometry.bed=zeros(md.mesh.numberofvertices,1);
    55md.geometry.surface=md.geometry.bed+md.geometry.thickness;
    66
    77disp('      creating drag');
    8 md.friction.coefficient=20*ones(md.numberofnodes,1); %q=1. %no drag is specified in the analytical solution
    9 md.friction.p=ones(md.numberofelements,1);
    10 md.friction.q=ones(md.numberofelements,1);
     8md.friction.coefficient=20*ones(md.mesh.numberofvertices,1); %q=1. %no drag is specified in the analytical solution
     9md.friction.p=ones(md.mesh.numberofelements,1);
     10md.friction.q=ones(md.mesh.numberofelements,1);
    1111
    1212disp('      creating temperatures');
    … …  
    1515radius=sqrt((md.x).^2+(md.y).^2);
    1616md.initialization.temperature=(tmin+st*radius);
    17 md.basalforcings.geothermalflux=4.2*10^-2*ones(md.numberofnodes,1);
     17md.basalforcings.geothermalflux=4.2*10^-2*ones(md.mesh.numberofvertices,1);
    1818
    1919disp('      creating flow law paramter');
    20 md.materials.rheology_B=6.81*10^(7)*ones(md.numberofnodes,1); %to have the same B as the analytical solution
    21 md.materials.rheology_n=3*ones(md.numberofelements,1);
     20md.materials.rheology_B=6.81*10^(7)*ones(md.mesh.numberofvertices,1); %to have the same B as the analytical solution
     21md.materials.rheology_n=3*ones(md.mesh.numberofelements,1);
    2222
    2323disp('      creating surface mass balance');
    … …  
    3232md.inversion.vy_obs=constant/2*md.y.*(md.geometry.thickness).^-1;
    3333md.inversion.vel_obs=(sqrt((md.inversion.vx_obs).^2+(md.inversion.vy_obs).^2));
    34 md.initialization.vx=zeros(md.numberofnodes,1);
    35 md.initialization.vy=zeros(md.numberofnodes,1);
    36 md.initialization.vz=zeros(md.numberofnodes,1);
    37 md.initialization.pressure=zeros(md.numberofnodes,1);
     34md.initialization.vx=zeros(md.mesh.numberofvertices,1);
     35md.initialization.vy=zeros(md.mesh.numberofvertices,1);
     36md.initialization.vz=zeros(md.mesh.numberofvertices,1);
     37md.initialization.pressure=zeros(md.mesh.numberofvertices,1);
    3838
    3939%Deal with boundary conditions:

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

    r9714 r9725  
    3434
    3535%Initial velocity
    36 md.initialization.vx=zeros(md.numberofnodes,1);
    37 md.initialization.vy=zeros(md.numberofnodes,1);
    38 md.initialization.vz=zeros(md.numberofnodes,1);
    39 md.initialization.pressure=zeros(md.numberofnodes,1);
     36md.initialization.vx=zeros(md.mesh.numberofvertices,1);
     37md.initialization.vy=zeros(md.mesh.numberofvertices,1);
     38md.initialization.vz=zeros(md.mesh.numberofvertices,1);
     39md.initialization.pressure=zeros(md.mesh.numberofvertices,1);
    4040
    4141%Materials
    42 md.initialization.temperature=(273-20)*ones(md.numberofnodes,1);
     42md.initialization.temperature=(273-20)*ones(md.mesh.numberofvertices,1);
    4343md.materials.rheology_B=paterson(md.initialization.temperature);
    44 md.materials.rheology_n=3*ones(md.numberofelements,1);
     44md.materials.rheology_n=3*ones(md.mesh.numberofelements,1);
    4545
    4646%Surface mass balance and basal melting
    47 md.surfaceforcings.mass_balance=-10*ones(md.numberofnodes,1);
    48 md.basalforcings.melting_rate=zeros(md.numberofnodes,1);
     47md.surfaceforcings.mass_balance=-10*ones(md.mesh.numberofvertices,1);
     48md.basalforcings.melting_rate=zeros(md.mesh.numberofvertices,1);
    4949pos=find(md.mask.vertexonfloatingice);md.basalforcings.melting_rate(pos)=10;
    5050
    5151%Friction
    5252pos=find(md.mask.elementonfloatingice);
    53 md.friction.coefficient=20*ones(md.numberofnodes,1);
     53md.friction.coefficient=20*ones(md.mesh.numberofvertices,1);
    5454md.friction.coefficient(md.elements(pos,:))=0;
    55 md.friction.p=ones(md.numberofelements,1);
    56 md.friction.q=ones(md.numberofelements,1);
     55md.friction.p=ones(md.mesh.numberofelements,1);
     56md.friction.q=ones(md.mesh.numberofelements,1);
    5757
    5858%Numerical parameters
    … …  
    7575
    7676%Deal with boundary conditions:
    77 md.diagnostic.spcvx=NaN*ones(md.numberofnodes,1);
    78 md.diagnostic.spcvy=NaN*ones(md.numberofnodes,1);
    79 md.diagnostic.spcvz=NaN*ones(md.numberofnodes,1);
     77md.diagnostic.spcvx=NaN*ones(md.mesh.numberofvertices,1);
     78md.diagnostic.spcvy=NaN*ones(md.mesh.numberofvertices,1);
     79md.diagnostic.spcvz=NaN*ones(md.mesh.numberofvertices,1);
    8080
    8181pos=find(md.x==0 & md.y==0);
    … …  
    8686pressureload=[pressureload 1*md.mask.elementonfloatingice(pressureload(:,end)) + 0*md.mask.elementongroundedice(pressureload(:,end))];
    8787md.diagnostic.icefront=pressureload;
    88 md.balancethickness.spcthickness=NaN*ones(md.numberofnodes,1);
    89 md.prognostic.spcthickness=NaN*ones(md.numberofnodes,1);
    90 md.diagnostic.referential=NaN*ones(md.numberofnodes,6);
     88md.balancethickness.spcthickness=NaN*ones(md.mesh.numberofvertices,1);
     89md.prognostic.spcthickness=NaN*ones(md.mesh.numberofvertices,1);
     90md.diagnostic.referential=NaN*ones(md.mesh.numberofvertices,6);
    9191
    9292%Change name so that no test have the same name

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

    r9691 r9725  
    99
    1010disp('      creating drag');
    11 md.friction.coefficient=20*ones(md.numberofnodes,1); %q=1. %no drag is specified in the analytical solution
     11md.friction.coefficient=20*ones(md.mesh.numberofvertices,1); %q=1. %no drag is specified in the analytical solution
    1212%Take care of iceshelves: no basal drag
    1313pos=find(md.mask.elementonfloatingice);
    1414md.friction.coefficient(md.elements(pos,:))=0;
    15 md.friction.p=ones(md.numberofelements,1);
    16 md.friction.q=ones(md.numberofelements,1);
     15md.friction.p=ones(md.mesh.numberofelements,1);
     16md.friction.q=ones(md.mesh.numberofelements,1);
    1717
    1818disp('      creating temperatures');
    … …  
    2020st=1.67*10^-2/1000; %k/m;
    2121md.initialization.temperature=(tmin+st*radius);
    22 md.basalforcings.geothermalflux=4.2*10^-2*ones(md.numberofnodes,1);
     22md.basalforcings.geothermalflux=4.2*10^-2*ones(md.mesh.numberofvertices,1);
    2323
    2424disp('      creating flow law paramter');
    25 md.materials.rheology_B=6.81*10^(7)*ones(md.numberofnodes,1); %to have the same B as the analytical solution
    26 md.materials.rheology_n=3*ones(md.numberofelements,1);
     25md.materials.rheology_B=6.81*10^(7)*ones(md.mesh.numberofvertices,1); %to have the same B as the analytical solution
     26md.materials.rheology_n=3*ones(md.mesh.numberofelements,1);
    2727
    2828disp('      creating surface mass balance');
    … …  
    3737md.inversion.vy_obs=constant/2*md.y.*(md.geometry.thickness).^-1;
    3838md.inversion.vel_obs=(sqrt((md.inversion.vx_obs).^2+(md.inversion.vy_obs).^2));
    39 md.initialization.vx=zeros(md.numberofnodes,1);
    40 md.initialization.vy=zeros(md.numberofnodes,1);
    41 md.initialization.vz=zeros(md.numberofnodes,1);
    42 md.initialization.pressure=zeros(md.numberofnodes,1);
     39md.initialization.vx=zeros(md.mesh.numberofvertices,1);
     40md.initialization.vy=zeros(md.mesh.numberofvertices,1);
     41md.initialization.vz=zeros(md.mesh.numberofvertices,1);
     42md.initialization.pressure=zeros(md.mesh.numberofvertices,1);
    4343
    4444%Deal with boundary conditions:

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

    r9691 r9725  
    44ymin=min(md.y);
    55ymax=max(md.y);
    6 md.geometry.thickness=500*ones(md.numberofnodes,1);
     6md.geometry.thickness=500*ones(md.mesh.numberofvertices,1);
    77md.geometry.bed=-md.materials.rho_ice/md.materials.rho_water*md.geometry.thickness;
    88md.geometry.surface=md.geometry.bed+md.geometry.thickness;
    99
    1010disp('      creating drag');
    11 md.friction.coefficient=200*ones(md.numberofnodes,1); %q=1.
     11md.friction.coefficient=200*ones(md.mesh.numberofvertices,1); %q=1.
    1212%Take care of iceshelves: no basal drag
    1313pos=find(md.mask.elementonfloatingice);
    1414md.friction.coefficient(md.elements(pos,:))=0;
    15 md.friction.p=ones(md.numberofelements,1);
    16 md.friction.q=ones(md.numberofelements,1);
     15md.friction.p=ones(md.mesh.numberofelements,1);
     16md.friction.q=ones(md.mesh.numberofelements,1);
    1717
    1818disp('      creating temperature');
    19 md.initialization.temperature=(273-20)*ones(md.numberofnodes,1);
     19md.initialization.temperature=(273-20)*ones(md.mesh.numberofvertices,1);
    2020
    2121disp('      creating flow law paramter');
    22 md.materials.rheology_B=1.7687*10^8*ones(md.numberofnodes,1);
    23 md.materials.rheology_n=3*ones(md.numberofelements,1);
     22md.materials.rheology_B=1.7687*10^8*ones(md.mesh.numberofvertices,1);
     23md.materials.rheology_n=3*ones(md.mesh.numberofelements,1);
    2424
    2525disp('      creating surface mass balance');
    26 md.surfaceforcings.mass_balance=0.2*ones(md.numberofnodes,1); %0m/a
    27 md.basalforcings.melting_rate=0*ones(md.numberofnodes,1); %0m/a
     26md.surfaceforcings.mass_balance=0.2*ones(md.mesh.numberofvertices,1); %0m/a
     27md.basalforcings.melting_rate=0*ones(md.mesh.numberofvertices,1); %0m/a
    2828
    2929disp('      boundary conditions ');
    … …  
    3232%Evolution of the ice shelf
    3333pos=find(md.y==200000); %nodes on the upper boundary condition
    34 md.balancethickness.spcthickness=NaN*ones(md.numberofnodes,1);
     34md.balancethickness.spcthickness=NaN*ones(md.mesh.numberofvertices,1);
    3535md.balancethickness.spcthickness(pos)=500;
    36 md.prognostic.spcthickness=NaN*ones(md.numberofnodes,1);
     36md.prognostic.spcthickness=NaN*ones(md.mesh.numberofvertices,1);
    3737md.prognostic.spcthickness(pos)=500;
    3838md.prognostic.stabilization=0; %Better result with no artificial diffusivity

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

    r9702 r9725  
    1515md.initialization.vy=InterpFromMeshToMesh2d(index,x,y,vy,md.x,md.y);
    1616clear vx vy x y index;
    17 md.initialization.vz=zeros(md.numberofnodes,1);
    18 md.initialization.pressure=zeros(md.numberofnodes,1);
     17md.initialization.vz=zeros(md.mesh.numberofvertices,1);
     18md.initialization.pressure=zeros(md.mesh.numberofvertices,1);
    1919
    2020%Materials
    21 md.initialization.temperature=(273-20)*ones(md.numberofnodes,1);
     21md.initialization.temperature=(273-20)*ones(md.mesh.numberofvertices,1);
    2222md.materials.rheology_B=paterson(md.initialization.temperature);
    23 md.materials.rheology_n=3*ones(md.numberofelements,1);
     23md.materials.rheology_n=3*ones(md.mesh.numberofelements,1);
    2424
    2525%Friction
    2626pos=find(md.mask.elementonfloatingice);
    27 md.friction.coefficient=20*ones(md.numberofnodes,1);
     27md.friction.coefficient=20*ones(md.mesh.numberofvertices,1);
    2828md.friction.coefficient(md.elements(pos,:))=0;
    29 md.friction.p=ones(md.numberofelements,1);
    30 md.friction.q=ones(md.numberofelements,1);
     29md.friction.p=ones(md.mesh.numberofelements,1);
     30md.friction.q=ones(md.mesh.numberofelements,1);
    3131
    3232%Numerical parameters

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

    r9702 r9725  
    1818md.initialization.vy=InterpFromMeshToMesh2d(index,x,y,vy,md.x,md.y);
    1919clear vx vy x y index;
    20 md.initialization.vz=zeros(md.numberofnodes,1);
    21 md.initialization.pressure=zeros(md.numberofnodes,1);
     20md.initialization.vz=zeros(md.mesh.numberofvertices,1);
     21md.initialization.pressure=zeros(md.mesh.numberofvertices,1);
    2222
    2323%Materials
    24 md.initialization.temperature=(273-20)*ones(md.numberofnodes,1);
     24md.initialization.temperature=(273-20)*ones(md.mesh.numberofvertices,1);
    2525md.materials.rheology_B=paterson(md.initialization.temperature);
    26 md.materials.rheology_n=3*ones(md.numberofelements,1);
     26md.materials.rheology_n=3*ones(md.mesh.numberofelements,1);
    2727
    2828%Accumulation and melting
    29 md.surfaceforcings.mass_balance=10*ones(md.numberofnodes,1);
    30 md.basalforcings.melting_rate=5*ones(md.numberofnodes,1);
     29md.surfaceforcings.mass_balance=10*ones(md.mesh.numberofvertices,1);
     30md.basalforcings.melting_rate=5*ones(md.mesh.numberofvertices,1);
    3131
    3232%Friction
    3333pos=find(md.mask.elementonfloatingice);
    34 md.friction.coefficient=20*ones(md.numberofnodes,1);
     34md.friction.coefficient=20*ones(md.mesh.numberofvertices,1);
    3535md.friction.coefficient(md.elements(pos,:))=0;
    36 md.friction.p=ones(md.numberofelements,1);
    37 md.friction.q=ones(md.numberofelements,1);
     36md.friction.p=ones(md.mesh.numberofelements,1);
     37md.friction.q=ones(md.mesh.numberofelements,1);
    3838
    3939%Numerical parameters

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

    r9702 r9725  
    1515md.initialization.vy=InterpFromMeshToMesh2d(index,x,y,vy,md.x,md.y);
    1616clear vx vy x y index;
    17 md.initialization.vz=zeros(md.numberofnodes,1);
    18 md.initialization.pressure=zeros(md.numberofnodes,1);
     17md.initialization.vz=zeros(md.mesh.numberofvertices,1);
     18md.initialization.pressure=zeros(md.mesh.numberofvertices,1);
    1919
    2020%Materials
    21 md.initialization.temperature=(273-20)*ones(md.numberofnodes,1);
     21md.initialization.temperature=(273-20)*ones(md.mesh.numberofvertices,1);
    2222md.materials.rheology_B=paterson(md.initialization.temperature);
    23 md.materials.rheology_n=3*ones(md.numberofelements,1);
     23md.materials.rheology_n=3*ones(md.mesh.numberofelements,1);
    2424
    2525%Friction
    2626pos=find(md.mask.elementonfloatingice);
    27 md.friction.coefficient=20*ones(md.numberofnodes,1);
     27md.friction.coefficient=20*ones(md.mesh.numberofvertices,1);
    2828md.friction.coefficient(md.elements(pos,:))=0;
    29 md.friction.p=ones(md.numberofelements,1);
    30 md.friction.q=ones(md.numberofelements,1);
     29md.friction.p=ones(md.mesh.numberofelements,1);
     30md.friction.q=ones(md.mesh.numberofelements,1);
    3131
    3232%Numerical parameters

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

    r9702 r9725  
    1515md.initialization.vy=InterpFromMeshToMesh2d(index,x,y,vy,md.x,md.y);
    1616clear vx vy x y index;
    17 md.initialization.vz=zeros(md.numberofnodes,1);
    18 md.initialization.pressure=zeros(md.numberofnodes,1);
     17md.initialization.vz=zeros(md.mesh.numberofvertices,1);
     18md.initialization.pressure=zeros(md.mesh.numberofvertices,1);
    1919
    2020%Materials
    21 md.initialization.temperature=(273-20)*ones(md.numberofnodes,1);
     21md.initialization.temperature=(273-20)*ones(md.mesh.numberofvertices,1);
    2222md.materials.rheology_B=paterson(md.initialization.temperature);
    23 md.materials.rheology_n=3*ones(md.numberofelements,1);
     23md.materials.rheology_n=3*ones(md.mesh.numberofelements,1);
    2424
    2525%Surface mass balance and basal melting
    26 md.surfaceforcings.mass_balance=10*ones(md.numberofnodes,1);
    27 md.basalforcings.melting_rate=5*ones(md.numberofnodes,1);
     26md.surfaceforcings.mass_balance=10*ones(md.mesh.numberofvertices,1);
     27md.basalforcings.melting_rate=5*ones(md.mesh.numberofvertices,1);
    2828
    2929%Friction
    3030pos=find(md.mask.elementonfloatingice);
    31 md.friction.coefficient=20*ones(md.numberofnodes,1);
     31md.friction.coefficient=20*ones(md.mesh.numberofvertices,1);
    3232md.friction.coefficient(md.elements(pos,:))=0;
    33 md.friction.p=ones(md.numberofelements,1);
    34 md.friction.q=ones(md.numberofelements,1);
     33md.friction.p=ones(md.mesh.numberofelements,1);
     34md.friction.q=ones(md.mesh.numberofelements,1);
    3535
    3636%Numerical parameters

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

    r9691 r9725  
    55disp('      creating thickness');
    66h=1000;
    7 md.geometry.thickness=h*ones(md.numberofnodes,1);
    8 md.geometry.bed=-1000*ones(md.numberofnodes,1);
     7md.geometry.thickness=h*ones(md.mesh.numberofvertices,1);
     8md.geometry.bed=-1000*ones(md.mesh.numberofvertices,1);
    99md.geometry.surface=md.geometry.bed+md.geometry.thickness;
    1010
    1111disp('      creating velocities');
    12 md.initialization.vx=zeros(md.numberofnodes,1);
    13 md.initialization.vy=zeros(md.numberofnodes,1);
    14 md.initialization.vz=zeros(md.numberofnodes,1);
     12md.initialization.vx=zeros(md.mesh.numberofvertices,1);
     13md.initialization.vy=zeros(md.mesh.numberofvertices,1);
     14md.initialization.vz=zeros(md.mesh.numberofvertices,1);
    1515
    1616disp('      creating drag');
    17 md.friction.coefficient=200*ones(md.numberofnodes,1); %q=1.
     17md.friction.coefficient=200*ones(md.mesh.numberofvertices,1); %q=1.
    1818%Take care of iceshelves: no basal drag
    1919pos=find(md.mask.elementonfloatingice);
    2020md.friction.coefficient(md.elements(pos,:))=0;
    21 md.friction.p=ones(md.numberofelements,1);
    22 md.friction.q=ones(md.numberofelements,1);
     21md.friction.p=ones(md.mesh.numberofelements,1);
     22md.friction.q=ones(md.mesh.numberofelements,1);
    2323
    2424disp('      creating temperatures');
    25 md.initialization.temperature=(273-20)*ones(md.numberofnodes,1);
     25md.initialization.temperature=(273-20)*ones(md.mesh.numberofvertices,1);
    2626
    2727disp('      creating flow law paramter');
    2828md.materials.rheology_B=paterson(md.initialization.temperature);
    29 md.materials.rheology_n=3*ones(md.numberofelements,1);
     29md.materials.rheology_n=3*ones(md.mesh.numberofelements,1);
    3030
    3131disp('      creating surface mass balance');
    32 md.surfaceforcings.mass_balance=ones(md.numberofnodes,1)/md.constants.yts; %1m/a
    33 md.basalforcings.melting_rate=0*ones(md.numberofnodes,1)/md.constants.yts; %1m/a
     32md.surfaceforcings.mass_balance=ones(md.mesh.numberofvertices,1)/md.constants.yts; %1m/a
     33md.basalforcings.melting_rate=0*ones(md.mesh.numberofvertices,1)/md.constants.yts; %1m/a
    3434
    3535%Deal with boundary conditions:
    … …  
    4040disp('      boundary conditions for thermal model');
    4141md.thermal.spctemperature(:)=md.initialization.temperature;
    42 md.basalforcings.geothermalflux=zeros(md.numberofnodes,1);
     42md.basalforcings.geothermalflux=zeros(md.mesh.numberofvertices,1);
    4343pos=find(md.mask.elementongroundedice);md.basalforcings.geothermalflux(md.elements(pos,:))=1*10^-3; %1 mW/m^2
Note: See TracChangeset for help on using the changeset viewer.