Changeset 9719


Ignore:
Timestamp:
09/09/11 07:53:32 (14 years ago)
Author:
Mathieu Morlighem
Message:

Added some mesh objects

Location:
issm/trunk/src
Files:
1 added
5 deleted
92 edited

Legend:

Unmodified
Added
Removed

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

    r9718 r9719  
    148148        AutodiffReverseEnum,
    149149        MeshAverageVertexConnectivityEnum,
     150        MeshDimensionEnum,
    150151        /*}}}*/
    151152        /*Datasets {{{1*/
    … …  
    411412        OldGradientEnum,
    412413        ControlSteadyEnum,
    413         DimEnum,
    414414        NumberOfElementsEnum,
    415415        NumberOfVerticesEnum,
    … …  
    485485        SpcDynamicEnum,
    486486        NumberOfEdgesEnum,
    487         /*Automatic differentiation: */
    488         AdAnalysisEnum,
    489         AdForwardEnum,
    490         AdReverseEnum,
    491487        MaximumNumberOfEnums
    492488};

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

    r9718 r9719  
    152152                case AutodiffReverseEnum : return "AutodiffReverse";
    153153                case MeshAverageVertexConnectivityEnum : return "MeshAverageVertexConnectivity";
     154                case MeshDimensionEnum : return "MeshDimension";
    154155                case ConstraintsEnum : return "Constraints";
    155156                case ElementsEnum : return "Elements";
    … …  
    363364                case OldGradientEnum : return "OldGradient";
    364365                case ControlSteadyEnum : return "ControlSteady";
    365                 case DimEnum : return "Dim";
    366366                case NumberOfElementsEnum : return "NumberOfElements";
    367367                case NumberOfVerticesEnum : return "NumberOfVertices";
    … …  
    429429                case SpcDynamicEnum : return "SpcDynamic";
    430430                case NumberOfEdgesEnum : return "NumberOfEdges";
    431                 case AdAnalysisEnum : return "AdAnalysis";
    432                 case AdForwardEnum : return "AdForward";
    433                 case AdReverseEnum : return "AdReverse";
    434431                default : return "unknown";
    435432

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

    r4967 r9719  
    1818       
    1919        /*retrieve some parameters: */
    20         parameters->FindParam(&dim,DimEnum);
     20        parameters->FindParam(&dim,MeshDimensionEnum);
    2121        numberofvertices=vertices->NumberOfVertices();
    2222

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

    r9661 r9719  
    3030
    3131        /*Fetch parameters: */
    32         iomodel->Constant(&dim,DimEnum);
     32        iomodel->Constant(&dim,MeshDimensionEnum);
    3333        iomodel->Constant(&numberofelements,NumberOfElementsEnum);
    3434        iomodel->Constant(&numberofvertices,NumberOfVerticesEnum);

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

    r9646 r9719  
    2020
    2121        /*Fetch data needed: */
    22         iomodel->Constant(&dim,DimEnum);
     22        iomodel->Constant(&dim,MeshDimensionEnum);
    2323        iomodel->Constant(&numberofelements,NumberOfElementsEnum);
    2424        iomodel->FetchData(1,ElementsEnum);

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

    r9641 r9719  
    2020
    2121        /*Fetch data needed: */
    22         iomodel->Constant(&dim,DimEnum);
     22        iomodel->Constant(&dim,MeshDimensionEnum);
    2323        iomodel->Constant(&numberofelements,NumberOfElementsEnum);
    2424        iomodel->FetchData(1,ElementsEnum);

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

    r9681 r9719  
    2828
    2929        /*Fetch parameters: */
    30         iomodel->Constant(&dim,DimEnum);
     30        iomodel->Constant(&dim,MeshDimensionEnum);
    3131        iomodel->Constant(&numberofelements,NumberOfElementsEnum);
    3232        iomodel->Constant(&numberofvertices,NumberOfVerticesEnum);

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

    r9405 r9719  
    2929
    3030        /*Fetch parameters: */
    31         iomodel->Constant(&dim,DimEnum);
     31        iomodel->Constant(&dim,MeshDimensionEnum);
    3232        iomodel->Constant(&numberofelements,NumberOfElementsEnum);
    3333        iomodel->Constant(&numberofvertices,NumberOfVerticesEnum);

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

    r9718 r9719  
    2525               
    2626        /*Copy some constants from iomodel */
    27         parameters->AddObject(iomodel->CopyConstantObject(DimEnum));
     27        parameters->AddObject(iomodel->CopyConstantObject(MeshDimensionEnum));
    2828        parameters->AddObject(iomodel->CopyConstantObject(FlowequationIshutterEnum));
    2929        parameters->AddObject(iomodel->CopyConstantObject(FlowequationIsmacayealpattynEnum));

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

    r9405 r9719  
    3232
    3333        /*Fetch parameters: */
    34         iomodel->Constant(&dim,DimEnum);
     34        iomodel->Constant(&dim,MeshDimensionEnum);
    3535        iomodel->Constant(&numberofelements,NumberOfElementsEnum);
    3636        iomodel->Constant(&numberofvertices,NumberOfVerticesEnum);

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

    r9679 r9719  
    3939
    4040        /*Fetch parameters: */
    41         iomodel->Constant(&dim,DimEnum);
     41        iomodel->Constant(&dim,MeshDimensionEnum);
    4242        iomodel->Constant(&yts,ConstantsYtsEnum);
    4343        iomodel->Constant(&numberofvertices,NumberOfVerticesEnum);

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

    r9679 r9719  
    4040
    4141        /*Fetch parameters: */
    42         iomodel->Constant(&dim,DimEnum);
     42        iomodel->Constant(&dim,MeshDimensionEnum);
    4343        iomodel->Constant(&numberofvertices,NumberOfVerticesEnum);
    4444        iomodel->Constant(&isstokes,FlowequationIsstokesEnum);

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

    r9691 r9719  
    2626        iomodel->Constant(&isstokes,FlowequationIsstokesEnum);
    2727        iomodel->Constant(&ismacayealpattyn,FlowequationIsmacayealpattynEnum);
    28         iomodel->Constant(&dim,DimEnum);
     28        iomodel->Constant(&dim,MeshDimensionEnum);
    2929        iomodel->Constant(&numberofelements,NumberOfElementsEnum);
    3030        iomodel->Constant(&control_analysis,InversionIscontrolEnum);

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

    r9679 r9719  
    2424
    2525        /*Fetch parameters: */
    26         iomodel->Constant(&dim,DimEnum);
     26        iomodel->Constant(&dim,MeshDimensionEnum);
    2727        iomodel->Constant(&yts,ConstantsYtsEnum);
    2828        iomodel->Constant(&numberofvertices,NumberOfVerticesEnum);

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

    r9661 r9719  
    2525
    2626        /*Fetch parameters: */
    27         iomodel->Constant(&dim,DimEnum);
     27        iomodel->Constant(&dim,MeshDimensionEnum);
    2828        iomodel->Constant(&numberofvertices,NumberOfVerticesEnum);
    2929

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

    r9691 r9719  
    2020
    2121        /*Fetch parameters: */
    22         iomodel->Constant(&dim,DimEnum);
     22        iomodel->Constant(&dim,MeshDimensionEnum);
    2323        iomodel->Constant(&numberofelements,NumberOfElementsEnum);
    2424

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

    r9679 r9719  
    4848
    4949        /*Fetch parameters: */
    50         iomodel->Constant(&dim,DimEnum);
     50        iomodel->Constant(&dim,MeshDimensionEnum);
    5151        iomodel->Constant(&numberofelements,NumberOfElementsEnum);
    5252        iomodel->Constant(&numberofvertices,NumberOfVerticesEnum);

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

    r9636 r9719  
    2626
    2727        /*Fetch parameters: */
    28         iomodel->Constant(&dim,DimEnum);
     28        iomodel->Constant(&dim,MeshDimensionEnum);
    2929        iomodel->Constant(&numberofvertices,NumberOfVerticesEnum);
    3030        iomodel->Constant(&heatcapacity,MaterialsHeatcapacityEnum);

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

    r9661 r9719  
    2020
    2121        /*Fetch parameters: */
    22         iomodel->Constant(&dim,DimEnum);
     22        iomodel->Constant(&dim,MeshDimensionEnum);
    2323        iomodel->Constant(&numberofelements,NumberOfElementsEnum);
    2424

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

    r9641 r9719  
    2222
    2323        /*Fetch parameters: */
    24         iomodel->Constant(&dim,DimEnum);
     24        iomodel->Constant(&dim,MeshDimensionEnum);
    2525        iomodel->Constant(&numberofvertices,NumberOfVerticesEnum);
    2626

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

    r9661 r9719  
    2020
    2121        /*Fetch parameters: */
    22         iomodel->Constant(&dim,DimEnum);
     22        iomodel->Constant(&dim,MeshDimensionEnum);
    2323        iomodel->Constant(&numberofelements,NumberOfElementsEnum);
    2424

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

    r9405 r9719  
    3737
    3838        /*Fetch parameters: */
    39         iomodel->Constant(&dim,DimEnum);
     39        iomodel->Constant(&dim,MeshDimensionEnum);
    4040        iomodel->Constant(&verbose,VerboseEnum);
    4141       

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

    r9405 r9719  
    7878
    7979        /*Fetch parameters: */
    80         iomodel->Constant(&dim,DimEnum);
     80        iomodel->Constant(&dim,MeshDimensionEnum);
    8181
    8282        /*Build discontinuous node partitioning

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

    r9661 r9719  
    3030
    3131        /*Fetch parameters: */
    32         iomodel->Constant(&dim,DimEnum);
     32        iomodel->Constant(&dim,MeshDimensionEnum);
    3333        iomodel->Constant(&numberofelements,NumberOfElementsEnum);
    3434        iomodel->Constant(&numberofvertices,NumberOfVerticesEnum);

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

    r9642 r9719  
    2121
    2222        /*Fetch data needed: */
    23         iomodel->Constant(&dim,DimEnum);
     23        iomodel->Constant(&dim,MeshDimensionEnum);
    2424        iomodel->Constant(&numberofelements,NumberOfElementsEnum);
    2525        iomodel->Constant(&stabilization,PrognosticStabilizationEnum);

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

    r9641 r9719  
    2020
    2121        /*Fetch data needed: */
    22         iomodel->Constant(&dim,DimEnum);
     22        iomodel->Constant(&dim,MeshDimensionEnum);
    2323        iomodel->Constant(&numberofelements,NumberOfElementsEnum);
    2424        iomodel->FetchData(1,ElementsEnum);

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

    r9632 r9719  
    2323
    2424        /*Fetch parameters: */
    25         iomodel->Constant(&dim,DimEnum);
     25        iomodel->Constant(&dim,MeshDimensionEnum);
    2626
    2727        /*Recover pointer: */

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

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

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

    r9661 r9719  
    2121
    2222        /*Fetch parameters: */
    23         iomodel->Constant(&dim,DimEnum);
     23        iomodel->Constant(&dim,MeshDimensionEnum);
    2424        iomodel->Constant(&numberofelements,NumberOfElementsEnum);
    2525        iomodel->Constant(&dakota_analysis,QmuIsdakotaEnum);

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

    r9718 r9719  
    150150        else if (strcmp(name,"AutodiffReverse")==0) return AutodiffReverseEnum;
    151151        else if (strcmp(name,"MeshAverageVertexConnectivity")==0) return MeshAverageVertexConnectivityEnum;
     152        else if (strcmp(name,"MeshDimension")==0) return MeshDimensionEnum;
    152153        else if (strcmp(name,"Constraints")==0) return ConstraintsEnum;
    153154        else if (strcmp(name,"Elements")==0) return ElementsEnum;
    … …  
    361362        else if (strcmp(name,"OldGradient")==0) return OldGradientEnum;
    362363        else if (strcmp(name,"ControlSteady")==0) return ControlSteadyEnum;
    363         else if (strcmp(name,"Dim")==0) return DimEnum;
    364364        else if (strcmp(name,"NumberOfElements")==0) return NumberOfElementsEnum;
    365365        else if (strcmp(name,"NumberOfVertices")==0) return NumberOfVerticesEnum;
    … …  
    427427        else if (strcmp(name,"SpcDynamic")==0) return SpcDynamicEnum;
    428428        else if (strcmp(name,"NumberOfEdges")==0) return NumberOfEdgesEnum;
    429         else if (strcmp(name,"AdAnalysis")==0) return AdAnalysisEnum;
    430         else if (strcmp(name,"AdForward")==0) return AdForwardEnum;
    431         else if (strcmp(name,"AdReverse")==0) return AdReverseEnum;
    432429        else _error_("Enum %s not found",name);
    433430

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

    r9697 r9719  
    535535        GetVerticesCoordinates(&xyz_list[0][0], nodes, NUMVERTICES);
    536536        this->parameters->FindParam(&stabilization,BalancethicknessStabilizationEnum);
    537         this->parameters->FindParam(&dim,DimEnum);
     537        this->parameters->FindParam(&dim,MeshDimensionEnum);
    538538        Input* vxaverage_input=NULL;
    539539        Input* vyaverage_input=NULL;
    … …  
    643643        /*Retrieve all inputs and parameters*/
    644644        GetVerticesCoordinates(&xyz_list[0][0], nodes, NUMVERTICES);
    645         this->parameters->FindParam(&dim,DimEnum);
     645        this->parameters->FindParam(&dim,MeshDimensionEnum);
    646646        Input* vx_input=inputs->GetInput(VxEnum); _assert_(vx_input);
    647647        Input* vy_input=inputs->GetInput(VyEnum); _assert_(vy_input);
    … …  
    10281028        GetVerticesCoordinates(&xyz_list[0][0], nodes, NUMVERTICES);
    10291029        this->parameters->FindParam(&dt,TimesteppingTimeStepEnum);
    1030         this->parameters->FindParam(&dim,DimEnum);
     1030        this->parameters->FindParam(&dim,MeshDimensionEnum);
    10311031        this->parameters->FindParam(&stabilization,PrognosticStabilizationEnum);
    10321032        Input* vxaverage_input=NULL;
    … …  
    11381138        GetVerticesCoordinates(&xyz_list[0][0], nodes, NUMVERTICES);
    11391139        this->parameters->FindParam(&dt,TimesteppingTimeStepEnum);
    1140         this->parameters->FindParam(&dim,DimEnum);
     1140        this->parameters->FindParam(&dim,MeshDimensionEnum);
    11411141        Input* vxaverage_input=NULL;
    11421142        Input* vyaverage_input=NULL;

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

    r9679 r9719  
    5454       
    5555        /*find parameters: */
    56         iomodel->Constant(&dim,DimEnum);
     56        iomodel->Constant(&dim,MeshDimensionEnum);
    5757        iomodel->Constant(&numberofelements,NumberOfElementsEnum);
    5858

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

    r9681 r9719  
    602602                                                        parameters=((Penta*)(element))->parameters;
    603603                                                }
    604                                                 parameters->FindParam(&dim,DimEnum);
     604                                                parameters->FindParam(&dim,MeshDimensionEnum);
    605605                                                if(dim==2){
    606606                                                        /*Dupliacte rheology input: */
    … …  
    660660
    661661        /*Fetch parameters: */
    662         iomodel->Constant(&dim,DimEnum);
     662        iomodel->Constant(&dim,MeshDimensionEnum);
    663663        iomodel->Constant(&control_analysis,InversionIscontrolEnum);
    664664        iomodel->Constant(&num_control_type,InversionNumControlParametersEnum);

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

    r9661 r9719  
    3737
    3838        /*Fetch parameters: */
    39         iomodel->Constant(&dim,DimEnum);
     39        iomodel->Constant(&dim,MeshDimensionEnum);
    4040
    4141        /*id: */

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

    r9681 r9719  
    2323       
    2424        /*recover parameters: */
    25         femmodel->parameters->FindParam(&dim,DimEnum);
     25        femmodel->parameters->FindParam(&dim,MeshDimensionEnum);
    2626        femmodel->parameters->FindParam(&control_analysis,InversionIscontrolEnum);
    2727        femmodel->parameters->FindParam(&solution_type,SolutionTypeEnum);

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

    r9681 r9719  
    2020
    2121        /*Recover some parameters: */
    22         femmodel->parameters->FindParam(&dim,DimEnum);
     22        femmodel->parameters->FindParam(&dim,MeshDimensionEnum);
    2323        femmodel->parameters->FindParam(&control_analysis,InversionIscontrolEnum);
    2424        femmodel->parameters->FindParam(&solution_type,SolutionTypeEnum);

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

    r9681 r9719  
    5454        femmodel->parameters->FindParam(&eps_cm,InversionCostFunctionThresholdEnum);
    5555        femmodel->parameters->FindParam(&cm_gradient,InversionGradientOnlyEnum);
    56         femmodel->parameters->FindParam(&dim,DimEnum);
     56        femmodel->parameters->FindParam(&dim,MeshDimensionEnum);
    5757        femmodel->parameters->FindParam(&solution_type,SolutionTypeEnum);
    5858        femmodel->parameters->FindParam(&isstokes,FlowequationIsstokesEnum);

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

    r9681 r9719  
    2828
    2929        /* recover parameters:*/
    30         femmodel->parameters->FindParam(&dim,DimEnum);
     30        femmodel->parameters->FindParam(&dim,MeshDimensionEnum);
    3131        femmodel->parameters->FindParam(&ishutter,FlowequationIshutterEnum);
    3232        femmodel->parameters->FindParam(&ismacayealpattyn,FlowequationIsmacayealpattynEnum);

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

    r9681 r9719  
    2626       
    2727        /* recover parameters:*/
    28         femmodel->parameters->FindParam(&dim,DimEnum);
     28        femmodel->parameters->FindParam(&dim,MeshDimensionEnum);
    2929        femmodel->parameters->FindParam(&control_analysis,InversionIscontrolEnum);
    3030        femmodel->parameters->FindParam(&solution_type,SolutionTypeEnum);

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

    r9681 r9719  
    2020
    2121        /*Recover some parameters: */
    22         femmodel->parameters->FindParam(&dim,DimEnum);
     22        femmodel->parameters->FindParam(&dim,MeshDimensionEnum);
    2323        femmodel->parameters->FindParam(&control_analysis,InversionIscontrolEnum);
    2424        femmodel->parameters->FindParam(&solution_type,SolutionTypeEnum);

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

    r9702 r9719  
    3030
    3131        //first recover parameters common to all solutions
    32         femmodel->parameters->FindParam(&dim,DimEnum);
     32        femmodel->parameters->FindParam(&dim,MeshDimensionEnum);
    3333        femmodel->parameters->FindParam(&finaltime,TimesteppingFinalTimeEnum);
    3434        femmodel->parameters->FindParam(&dt,TimesteppingTimeStepEnum);

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

    r9714 r9719  
    1515                segments             = modelfield('default',NaN,'marshall',false);
    1616                segmentmarkers       = modelfield('default',NaN,'marshall',false);
     17                dimension            = modelfield('default',0,'marshall',true,'format','Integer');
    1718        end
    1819        methods
    … …  
    5152                        disp(sprintf('   Mesh:'));
    5253
    53                         if obj.dim==3,
     54                        if obj.dimension==3,
    5455                                disp(sprintf('\n      Elements and nodes of the original 2d mesh:'));
    5556                                fielddisplay(obj,'numberofelements2d','number of elements');
    … …  
    7374
    7475                        disp(sprintf('\n      Properties:'));
    75                         fielddisplay(obj,'dim','mesh dimension (2d or 3d)');
     76                        fielddisplay(obj,'dimension','mesh dimension (2d or 3d)');
    7677                        fielddisplay(obj,'numlayers','number of extrusion layers');
    7778                        fielddisplay(obj,'penalties','penalties list');

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

    r9714 r9719  
    4242
    4343                 %FIXME: all other fields should belong to other classes
    44 
    45                  dim                 = modelfield('default',0,'marshall',true,'format','Integer');
    4644                 numberofelements    = modelfield('default',0,'marshall',true,'format','Integer');
    4745                 numberofnodes       = modelfield('default',0,'marshall',true,'format','Integer');
    … …  
    318316                         if isfield(structmd,'segments'), md.mesh.segments=structmd.segments; end
    319317                         if isfield(structmd,'segmentmarkers'), md.mesh.segmentmarkers=structmd.segmentmarkers; end
     318                         if isfield(structmd,'dimension'), md.mesh.dimension=structmd.dimension; end
    320319
    321320                         %Field changes
    322321                         if (isfield(structmd,'type') & ischar(structmd.type)),
    323                                  if strcmpi(structmd.type,'2d'), md.dim=2; end
    324                                  if strcmpi(structmd.type,'3d'), md.dim=3; end
     322                                 if strcmpi(structmd.type,'2d'), md.mesh.dimension=2; end
     323                                 if strcmpi(structmd.type,'3d'), md.mesh.dimension=3; end
    325324                         end
    326325                         if isnumeric(md.verbose),

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

    r9691 r9719  
    99
    1010%check that the model given in input is 3d
    11 if ~md.dim==3;
     11if ~md.mesh.dimension==3;
    1212        error('DepthAverage error message: the model given in input must be 3d')
    1313end

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

    r3994 r9719  
    1212
    1313%make 3d work in 2d:
    14 if md.dim==3,
     14if md.mesh.dimension==3,
    1515        md.x=md.x2d;
    1616        md.y=md.y2d;

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

    r9691 r9719  
    3030        error('SectionValues error message: wrong resolution type. Resolution must be an array [horizontal_resolution vertical_resolution]')
    3131end
    32 if md.dim==3
     32if md.mesh.dimension==3
    3333        if (length(resolution)==2 & isnumeric(resolution(2)))
    3434                res_v=resolution(2);
    … …  
    7979
    8080%New mesh and Data interpolation
    81 if (md.dim==2)
     81if (md.mesh.dimension==2)
    8282
    8383        %Interpolation of data on specified points

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

    r9684 r9719  
    3131%build some variables
    3232line=index(:);
    33 if md.dim==3
     33if md.mesh.dimension==3
    3434        rep=6;
    3535        areas=GetAreas(index,md.x,md.y,md.z);

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

    r9714 r9719  
    265265
    266266% Bamg Mesh parameters {{{1
    267 if (~exist(options,'domain') & md.numberofnodes~=0 & md.dim==2),
     267if (~exist(options,'domain') & md.numberofnodes~=0 & md.mesh.dimension==2),
    268268
    269269        if isstruct(md.private.bamg),
    … …  
    325325
    326326%Fill in rest of fields:
    327 md.dim=2;
     327md.mesh.dimension=2;
    328328md.numberofelements=size(md.elements,1);
    329329md.numberofnodes=length(md.x);

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

    r9691 r9719  
    66
    77%load some variables (it is much faster if the variab;es are loaded from md once for all)
    8 if (md.dim==2),
     8if (md.mesh.dimension==2),
    99        numberofelements=md.numberofelements;
    1010        numberofnodes=md.numberofnodes;
    … …  
    2626b=sqrt(bx.^2+by.^2);
    2727
    28 if md.dim==3,
     28if md.mesh.dimension==3,
    2929        bx=project3d(md,bx,'element');
    3030        by=project3d(md,by,'element');

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

    r9714 r9719  
    1212
    1313%Check that the model is really a 3d model
    14 if ~md.dim==3,
     14if ~md.mesh.dimension==3,
    1515        error('collapse error message: only 3d mesh can be collapsed')
    1616end
    … …  
    110110
    111111%Update mesh type
    112 md.dim=2;
     112md.mesh.dimension=2;

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

    r9532 r9719  
    1111disp(sprintf('   Mesh:'));
    1212
    13 if md.dim==3,
     13if md.mesh.dimension==3,
    1414
    1515        disp(sprintf('\n      Elements and nodes of the original 2d mesh:'));

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

    r9451 r9719  
    55%      div=divergence(md,a,b)
    66
    7 if (md.dim==2),
     7if (md.mesh.dimension==2),
    88        numberofelements=md.numberofelements;
    99        numberofnodes=md.numberofnodes;

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

    r9714 r9719  
    110110
    111111%Update mesh type
    112 md.dim=3;
     112md.mesh.dimension=3;
    113113
    114114%Build global 3d mesh

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

    r9714 r9719  
    4949%ELEMENTS{{{1
    5050fields={'elements'};
    51 if (md.dim==2),
     51if (md.mesh.dimension==2),
    5252        checksize(md,fields,[md.numberofelements 3]);
    5353else
    … …  
    7070%}}}
    7171%PRESSURELOAD{{{1
    72 if (md.dim==2),
     72if (md.mesh.dimension==2),
    7373        fields={'diagnostic.icefront'};
    7474        checksize(md,fields,[NaN 4]);
    75 elseif md.dim==3,
     75elseif md.mesh.dimension==3,
    7676        fields={'diagnostic.icefront'};
    7777        checksize(md,fields,[NaN 6]);
    … …  
    125125end
    126126if ~strcmp(md.groundingline.migration,'None'),
    127         if (md.dim==3 | strcmpi(md.cluster.name,'none')),
     127        if (md.mesh.dimension==3 | strcmpi(md.cluster.name,'none')),
    128128                message(['model ' md.miscellaneous.name ' requesting grounding line migration, but grounding line module only implemented for 2d models and parallel runs!']);
    129129        end
    … …  
    145145%RIFTS{{{1
    146146if md.rifts.numrifts,
    147         if ~(md.dim==2),
     147        if ~(md.mesh.dimension==2),
    148148                message(['model not consistent: models with rifts are only supported in 2d for now!']);
    149149        end
    … …  
    187187%}}}
    188188%CONNECTIVITY {{{1
    189 if (md.dim==2),
     189if (md.mesh.dimension==2),
    190190        if md.mesh.average_vertex_connectivity<9,
    191191                message('model not consistent: connectivity should be at least 9 for 2d models');
    192192        end
    193193end
    194 if md.dim==3,
     194if md.mesh.dimension==3,
    195195        if md.mesh.average_vertex_connectivity<24,
    196196                message('model not consistent: connectivity should be at least 24 for 3d models');
    … …  
    342342        end
    343343
    344         if (md.dim~=2),
     344        if (md.mesh.dimension~=2),
    345345                message(['model not consistent: for a ' md.private.solution ' computation, the grounding line module is only implemented in 2d !'])
    346346        end
    … …  
    390390                        end
    391391                        %CHECK THAT ROTATION IS IN THE (X,Y) PLANE FOR 2D MODELS
    392                         if md.dim==2,
     392                        if md.mesh.dimension==2,
    393393                                pos=find(sum(isnan(md.diagnostic.referential),2)==0  & md.flowequation.vertex_equation==2);
    394394                                if any(md.diagnostic.referential(pos,3:5)~=0);
    … …  
    410410                        %Check the values of flowequation.element_equation
    411411                        checkvalues(md,{'flowequation.element_equation'},[0:7]);
    412                         if (md.dim==2),
     412                        if (md.mesh.dimension==2),
    413413                                checkvalues(md,{'flowequation.element_equation'},[1 2]);
    414414                        end
    … …  
    423423                        %Check the values of flowequation.vertex_equation
    424424                        checkvalues(md,{'flowequation.vertex_equation'},[0:7]);
    425                         if (md.dim==2),
     425                        if (md.mesh.dimension==2),
    426426                                checkvalues(md,{'flowequation.vertex_equation'},[1 2]);
    427427                        end
    … …  
    432432                case DiagnosticVertAnalysisEnum,
    433433                        % {{{2
    434                         if md.dim==3,
     434                        if md.mesh.dimension==3,
    435435                                % No checks for now
    436436                        end
    … …  
    486486                        % {{{2
    487487                        %EXTRUSION
    488                         if (md.dim==2),
     488                        if (md.mesh.dimension==2),
    489489                                if md.private.solution==TransientSolutionEnum,
    490490                                        return;
    … …  
    534534                        % {{{2
    535535                        %EXTRUSION
    536                         if (md.dim==2),
     536                        if (md.mesh.dimension==2),
    537537                                if md.private.solution==TransientSolutionEnum,
    538538                                        return;

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

    r9684 r9719  
    1717        error(['the input velocity should be of size ' num2str(md.numberofnodes) '!'])
    1818end
    19 if ~(md.dim==2)
     19if ~(md.mesh.dimension==2)
    2020        error('only 2d model supported yet');
    2121end

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

    r9684 r9719  
    1414
    1515%some checks
    16 if ~(md.dim==2)
     16if ~(md.mesh.dimension==2)
    1717        error('meshadaptation error message: adaptation for 3d meshes not implemented yet')
    1818end

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

    r9714 r9719  
    3636
    3737%Fill in rest of fields:
    38 md.dim=2;
     38md.mesh.dimension=2;
    3939md.numberofelements=size(md.elements,1);
    4040md.numberofnodes=length(md.x);

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

    r9714 r9719  
    6969
    7070%type of model
    71 md.dim=2;
     71md.mesh.dimension=2;

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

    r9714 r9719  
    3333
    3434%type of model
    35 md.dim=2;
     35md.mesh.dimension=2;
    3636end
    3737

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

    r9714 r9719  
    66
    77%some checks
    8 if md.dim==3,
     8if md.mesh.dimension==3,
    99        error('reorder error message: 3d models not supported yet, exiting...')
    1010end

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

    r9714 r9719  
    9191
    9292%type of model
    93 md.dim=2;
     93md.mesh.dimension=2;

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

    r9714 r9719  
    8383
    8484%type of model
    85 md.dim=2;
     85md.mesh.dimension=2;

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

    r9684 r9719  
    99%
    1010
    11 if md.dim==2,
     11if md.mesh.dimension==2,
    1212        elements=md.elements;
    1313        x=md.x;

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

    r9641 r9719  
    2121
    2222%2D or 3D?
    23 if md.dim==3,
     23if md.mesh.dimension==3,
    2424        numberofelements=md.numberofelements2d; %this will be forgotten when we get out.
    2525        flags=project2d(md,flags,1);
    … …  
    7373for i=1:size(flag_list,1),
    7474        disp(['   ' num2str(i) '/' num2str(size(flag_list,1))]);
    75         if md.dim==3,
     75        if md.mesh.dimension==3,
    7676                flags2d=flag_list{i};
    7777                realflags=project3d(md,flags2d,'element');

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

    r9650 r9719  
    99
    1010%some checks
    11 if md.dim==3,
     11if md.mesh.dimension==3,
    1212        if nargin~=3,
    1313                error('layer should be provided onto which Area Averaging occurs');
    … …  
    5151
    5252%in 3D, restore 3D model:
    53 if md.dim==3,
     53if md.mesh.dimension==3,
    5454        md=md3d;
    5555end

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

    r9671 r9719  
    3030recomputeadjacency=getfieldvalue(options,'recomputeadjacency');
    3131
    32 if(md.dim==3),
     32if(md.mesh.dimension==3),
    3333        %partitioning essentially happens in 2D. So partition in 2D, then
    3434        %extrude the partition vector vertically.
    … …  
    9898
    9999%extrude if we are in 3D:
    100 if md.dim==3,
     100if md.mesh.dimension==3,
    101101        md=md3d;
    102102        part=project3d(md,'vector',part','type','node');

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

    r9714 r9719  
    5252
    5353%view
    54 if md.dim==3 & ~exist(options,'layer'),
     54if md.mesh.dimension==3 & ~exist(options,'layer'),
    5555        view(getfieldvalue(options,'view',3));
    5656else
    … …  
    6363        eval(['axis ' getfieldvalue(options,'axis')]);
    6464else
    65         if ((md.dim==2) | exist(options,'layer')),
     65        if ((md.mesh.dimension==2) | exist(options,'layer')),
    6666                axis tight equal;
    6767        else

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

    r9691 r9719  
    99
    1010%check layer
    11 if md.dim==3,
     11if md.mesh.dimension==3,
    1212        if getfieldvalue(options,'layer',1)~=1;
    1313                disp('plot_basaldrag warning: basal drag is displayed in the lower layer')

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

    r8472 r9719  
    1717end
    1818
    19 if (md.dim==2),
     19if (md.mesh.dimension==2),
    2020        %plot mesh
    2121        A=elements(:,1); B=elements(:,2); C=elements(:,3);

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

    r8472 r9719  
    2121end
    2222
    23 if ~md.dim==3,
     23if ~md.mesh.dimension==3,
    2424        error('no penalties to plot for ''2d'' model');
    2525elseif isempty(md.penalties),

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

    r9679 r9719  
    1414pressureload=md.diagnostic.icefront;
    1515
    16 if (md.dim==2),
     16if (md.mesh.dimension==2),
    1717
    1818        %plot mesh

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

    r9650 r9719  
    1313allsegments=md.qmu.mass_flux_segments;
    1414
    15 if (md.dim==2),
     15if (md.mesh.dimension==2),
    1616
    1717        %recover segments

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

    r8728 r9719  
    3232md3d=md;
    3333if exist(options,'layer')
    34         md.x=md.x2d; md.y=md.y2d; md.elements=md.elements2d; md.dim=2;
     34        md.x=md.x2d; md.y=md.y2d; md.elements=md.elements2d; md.mesh.dimension=2;
    3535end
    3636
    … …  
    189189%apply options
    190190options=addfielddefault(options,'title','Section value');
    191 if (md.dim==2)
     191if (md.mesh.dimension==2)
    192192        options=addfielddefault(options,'colorbar',0);
    193193end
    194 if ((md.dim==2) | getfieldvalue(options,'view')==2 )
     194if ((md.mesh.dimension==2) | getfieldvalue(options,'view')==2 )
    195195        options=addfielddefault(options,'xlabel','Curvilinear coordinate');
    196196        options=addfielddefault(options,'axis','auto');
    197197end
    198 if (md.dim==3 & getfieldvalue(options,'view')==2 )
     198if (md.mesh.dimension==3 & getfieldvalue(options,'view')==2 )
    199199        options=addfielddefault(options,'ylabel','z');
    200200end

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

    r9714 r9719  
    1414segments=md.mesh.segments;
    1515
    16 if (md.dim==2),
     16if (md.mesh.dimension==2),
    1717        %plot mesh
    1818        A=elements(:,1); B=elements(:,2); C=elements(:,3);

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

    r8472 r9719  
    1010upperplots=fix((i-1)/width);
    1111if upperplots==0, leftplots=i-1; else leftplots=i-width*upperplots-1; end
    12 if (md.dim==2)%3 components -> 3 indexes
     12if (md.mesh.dimension==2)%3 components -> 3 indexes
    1313        index1=4*width*upperplots+2*leftplots+1;
    1414        index2=index1+1;
    1515        index3=index1+width*2;
    16 elseif md.dim==3%6 components -> 6 indexes
     16elseif md.mesh.dimension==3%6 components -> 6 indexes
    1717        index1=3*3*width*upperplots+3*leftplots+1;
    1818        index2=index1+1;
    … …  
    2828[tensor.yy datatype]=processdata(md,tensor.yy,options);
    2929[tensor.xy datatype]=processdata(md,tensor.xy,options);
    30 if  md.dim==3
     30if  md.mesh.dimension==3
    3131        [tensor.xz datatype]=processdata(md,tensor.xz,options);
    3232        [tensor.yz datatype]=processdata(md,tensor.yz,options);
    … …  
    3434end
    3535
    36 if ((md.dim==2)),
     36if ((md.mesh.dimension==2)),
    3737        subplot(2*width,2*width,index1),
    3838        plot_unit(x,y,z,elements,tensor.xx,is2d,isplanet,datatype,options)

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

    r8472 r9719  
    1010upperplots=fix((i-1)/width);
    1111if upperplots==0, leftplots=i-1; else leftplots=i-width*upperplots-1; end
    12 if (md.dim==2)%3 components -> 3 indexes
     12if (md.mesh.dimension==2)%3 components -> 3 indexes
    1313        index1=4*width*upperplots+2*leftplots+1;
    1414        index2=index1+1;
    … …  
    1616        index4=index3+1;
    1717        newwidth=2*width;
    18 elseif md.dim==3%6 components -> 6 indexes
     18elseif md.mesh.dimension==3%6 components -> 6 indexes
    1919        index1=3*3*width*upperplots+3*leftplots+1;
    2020        index2=index1+1;
    … …  
    3131type2=[type 'axis2'];
    3232plot_tensor_principalaxis(md,options,newwidth,index2,tensor,type2,plot_options);
    33 if  md.dim==3
     33if  md.mesh.dimension==3
    3434        type3=[type 'axis3'];
    3535        plot_tensor_principalaxis(md,options,newwidth,index3,tensor,type3,plot_options);
    … …  
    4040[tensor.principalvalue1 datatype]=processdata(md,tensor.principalvalue1,options);
    4141[tensor.principalvalue2 datatype]=processdata(md,tensor.principalvalue2,options);
    42 if  md.dim==3
     42if  md.mesh.dimension==3
    4343        [tensor.principalvalue3 datatype]=processdata(md,tensor.principalvalue3,options);
    4444end
    4545
    46 if ((md.dim==2)),
     46if ((md.mesh.dimension==2)),
    4747        subplot(2*width,2*width,index3)
    4848        plot_unit(x,y,z,elements,tensor.principalvalue1,is2d,isplanet,datatype,options)

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

    r8472 r9719  
    1313[x y z elements is2d isplanet]=processmesh(md,[],options);
    1414
    15 if ((md.dim==2)),
     15if ((md.mesh.dimension==2)),
    1616        eval(['Vx=tensor.principalaxis' type(end) '(:,1); Vy=tensor.principalaxis' type(end) '(:,2);'])
    1717        eval(['value=tensor.principalvalue' type(end) ';']);
    … …  
    3333
    3434%plot quivers
    35 if (md.dim==2),
     35if (md.mesh.dimension==2),
    3636
    3737        %density

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

    r3994 r9719  
    4141clear string;
    4242
    43 if md.dim==3,
     43if md.mesh.dimension==3,
    4444        string='plotmodel(md';
    4545        for i=1:length(md.results.transient),
    … …  
    6767clear string;
    6868
    69 if md.dim==3,
     69if md.mesh.dimension==3,
    7070        string='plotmodel(md';
    7171        for i=2:length(md.results.transient),

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

    r8577 r9719  
    5858
    5959        %check length
    60         if datasize(1)~=md.numberofnodes & datasize(1)~=md.numberofelements & datasize(1)~=md.numberofnodes*6 & (md.dim==3 & ~(datasize(1)==md.numberofelements2d | datasize(1)==md.numberofnodes2d))
     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))
    6161                error('plotmodel error message: data not supported yet');
    6262        end
    … …  
    6767
    6868                %check number of columns, add zeros if necessary,
    69                 if (md.dim==3)
     69                if (md.mesh.dimension==3)
    7070                        if datasize(2)==2,
    7171                                data=[data, zeros(datasize(1),1)];
    … …  
    7373                                error('plotmodel error message: data provided should have 2 or 3 columns for quiver plot, and 1 for regular plot');
    7474                        end
    75                 %elseif ((md.dim==2) & datasize(2)~=2),
     75                %elseif ((md.mesh.dimension==2) & datasize(2)~=2),
    7676                %       error('plotmodel error message: data provided should have 2 columns for quiver plot, and 1 for regular plot');
    7777                end
    … …  
    8989
    9090        %treat the case datasize(1)=nodes2d
    91         if (md.dim==3 & datasize(1)==md.numberofnodes2d),
     91        if (md.mesh.dimension==3 & datasize(1)==md.numberofnodes2d),
    9292                data=project3d(md,data,'node');
    9393                datasize(1)=md.numberofnodes;
    … …  
    9696
    9797        %treat the case datasize(1)=nodes2d
    98         if (md.dim==3 & datasize(1)==md.numberofelements2d),
     98        if (md.mesh.dimension==3 & datasize(1)==md.numberofelements2d),
    9999                data=project3d(md,data,'element');
    100100                datasize(1)=md.numberofelements;

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

    r9714 r9719  
    4141
    4242        %is it a 2d plot?
    43         if (md.dim==2);
     43        if (md.mesh.dimension==2);
    4444                is2d=1;
    45         elseif (md.dim==3),
     45        elseif (md.mesh.dimension==3),
    4646                if getfieldvalue(options,'layer',0)>=1,
    4747                        is2d=1;
    … …  
    5050                end
    5151        else
    52                 error(['dim = ' num2str(md.dim) ' not supported yet']);
     52                error(['dim = ' num2str(md.mesh.dimension) ' not supported yet']);
    5353        end
    5454
    … …  
    6666else
    6767        %Process Patch
    68         if (md.dim==2),
     68        if (md.mesh.dimension==2),
    6969                elements=transpose(reshape(1:3*md.numberofelements,3,md.numberofelements));
    7070                x=transpose(reshape(md.x(data.index)',1,3*md.numberofelements));

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

    r9182 r9719  
    2323        error('bad usage');
    2424end
    25 if md.dim~=3
     25if md.mesh.dimension~=3
    2626        error('input model is not 3d');
    2727end

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

    r9679 r9719  
    5656
    5757%Check that no pattyn or stokes for 2d mesh
    58 if (md.dim==2),
     58if (md.mesh.dimension==2),
    5959        if any(stokesflag | pattynflag)
    6060                error('setflowequation error message: stokes and pattyn elements no allowed in 2d mesh, extrude it first')

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

    r9691 r9719  
    88%      [velx,vely,vel]=sia(md)
    99
    10 if md.dim~=2,
     10if md.mesh.dimension~=2,
    1111        error('Only 2d meshes are allowed to compute velocity balances');
    1212end

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

    r9691 r9719  
    66
    77%load some variables (it is much faster if the variab;es are loaded from md once for all)
    8 if (md.dim==2),
     8if (md.mesh.dimension==2),
    99        numberofelements=md.numberofelements;
    1010        numberofnodes=md.numberofnodes;
    … …  
    2626s=sqrt(sx.^2+sy.^2);
    2727
    28 if md.dim==3,
     28if md.mesh.dimension==3,
    2929        sx=project3d(md,sx,'element');
    3030        sy=project3d(md,sy,'element');

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

    r9684 r9719  
    99
    1010if strcmpi(string,'diagnostic'),
    11         if md.dim==2,
     11        if md.mesh.dimension==2,
    1212                if isfield(md.results.DiagnosticSolution,'VxAverage'),
    1313                        md.initialization.vx=PatchToVec(md.results.DiagnosticSolution.VxAverage);

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

    r8728 r9719  
    9797md.numberofelements=size(md.elements,1);
    9898
    99 md.dim=3;
     99md.mesh.dimension=3;

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

    r8728 r9719  
    1818md.numberofelements=size(md.elements,1);
    1919
    20 md.dim=3;
     20md.mesh.dimension=3;

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

    r9714 r9719  
    2727
    2828%segment on neumann (Ice Front) -> none
    29 if (md.dim==2)
     29if (md.mesh.dimension==2)
    3030        md.diagnostic.icefront=zeros(0,4);
    3131else

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

    r9714 r9719  
    4848%segment on Neumann (Ice Front)
    4949pos=find(nodeonicefront(md.mesh.segments(:,1)) | nodeonicefront(md.mesh.segments(:,2)));
    50 if (md.dim==2)
     50if (md.mesh.dimension==2)
    5151        pressureload=md.mesh.segments(pos,:);
    52 elseif md.dim==3
     52elseif md.mesh.dimension==3
    5353        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)];
    5454        pressureload=[];

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

    r9714 r9719  
    5858%segment on Neumann (Ice Front)
    5959pos=find(vertexonicefront(md.mesh.segments(:,1)) | vertexonicefront(md.mesh.segments(:,2)));
    60 if (md.dim==2)
     60if (md.mesh.dimension==2)
    6161        pressureload=md.mesh.segments(pos,:);
    62 elseif md.dim==3
     62elseif md.mesh.dimension==3
    6363        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)];
    6464        pressureload=[];

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

    r9714 r9719  
    8787md.elementonbed=ones(md.numberofelements,1);
    8888md.elementonsurface=ones(md.numberofelements,1);
    89 md.dim=2;
     89md.mesh.dimension=2;
    9090md=addnote(md,notes);
    9191

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

    r9714 r9719  
    7676
    7777%plug other field
    78 md.dim=2;
     78md.mesh.dimension=2;
Note: See TracChangeset for help on using the changeset viewer.