Changeset 16291


Ignore:
Timestamp:
10/03/13 14:53:55 (11 years ago)
Author:
Mathieu Morlighem
Message:

CHG: removed mesh dimension and replaced by meshtype (I know... type is not good but I could not come up with anything better), prepare changes for flowband model

Location:
issm/trunk-jpl/src/c
Files:
57 edited

Legend:

Unmodified
Added
Removed

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

    r16248 r16291  
    2121        int        nsteps;
    2222        IssmDouble tol_cm;
    23         int        dim;
    2423        int        solution_type;
    2524        bool       isFS;
    … …  
    5352        femmodel->parameters->FindParam(&cm_jump,NULL,InversionStepThresholdEnum);
    5453        femmodel->parameters->FindParam(&tol_cm,InversionCostFunctionThresholdEnum);
    55         femmodel->parameters->FindParam(&dim,MeshDimensionEnum);
    5654        femmodel->parameters->FindParam(&solution_type,SolutionTypeEnum);
    5755        femmodel->parameters->FindParam(&isFS,FlowequationIsFSEnum);

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

    r16219 r16291  
    1414        /*parameters: */
    1515        bool  dakota_analysis;
    16         int   dim;
     16        int   meshtype;
    1717        bool  isSIA,isSSA,isL1L2,isHO,isFS;
    1818        bool  conserve_loads    = true;
    … …  
    2424
    2525        /* recover parameters:*/
    26         femmodel->parameters->FindParam(&dim,MeshDimensionEnum);
     26        femmodel->parameters->FindParam(&meshtype,MeshTypeEnum);
    2727        femmodel->parameters->FindParam(&isSIA,FlowequationIsSIAEnum);
    2828        femmodel->parameters->FindParam(&isSSA,FlowequationIsSSAEnum);
    … …  
    7878        }
    7979
    80         if (dim==3 && (isSIA || isSSA || isL1L2 || isHO)){
     80        if (meshtype==Mesh3DEnum && (isSIA || isSSA || isL1L2 || isHO)){
    8181                if(VerboseSolution()) _printf0_("   computing vertical velocities\n");
    8282                femmodel->SetCurrentConfiguration(StressbalanceVerticalAnalysisEnum);
    … …  
    9090                InputToResultx(femmodel,VelEnum);
    9191                InputToResultx(femmodel,PressureEnum);
    92                 if(dim==3) InputToResultx(femmodel,VzEnum);
     92                if(meshtype==Mesh3DEnum) InputToResultx(femmodel,VzEnum);
    9393                femmodel->RequestedOutputsx(requested_outputs,numoutputs);
    9494        }

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

    r16219 r16291  
    2525        bool   time_adapt=false;
    2626        int    output_frequency;
    27         int    dim,groundingline_migration;
     27        int    meshtype,groundingline_migration;
    2828        int    numoutputs         = 0;
    29         int    *requested_outputs = NULL;
     29        int   *requested_outputs = NULL;
    3030
    3131        /*intermediary: */
    … …  
    3434
    3535        //first recover parameters common to all solutions
    36         femmodel->parameters->FindParam(&dim,MeshDimensionEnum);
     36        femmodel->parameters->FindParam(&meshtype,MeshTypeEnum);
    3737        femmodel->parameters->FindParam(&starttime,TimesteppingStartTimeEnum);
    3838        femmodel->parameters->FindParam(&finaltime,TimesteppingFinalTimeEnum);
    … …  
    6363                        InputDuplicatex(femmodel,QmuVxEnum,VxEnum);
    6464                        InputDuplicatex(femmodel,QmuVyEnum,VyEnum);
    65                         if(dim==3){
     65                        if(meshtype==Mesh3DEnum){
    6666                                InputDuplicatex(femmodel,QmuVzEnum,VzEnum);
    6767                                if(isFS)InputDuplicatex(femmodel,QmuPressureEnum,PressureEnum);
    … …  
    7575                }
    7676                if(isgroundingline) InputDuplicatex(femmodel,QmuMaskGroundediceLevelsetEnum,MaskGroundediceLevelsetEnum);
    77                 if(dim==2)InputDuplicatex(femmodel,QmuMaterialsRheologyBEnum,MaterialsRheologyBbarEnum);
    78                 if(isthermal && dim==3){
     77                if(meshtype==Mesh2DhorizontalEnum)InputDuplicatex(femmodel,QmuMaterialsRheologyBEnum,MaterialsRheologyBbarEnum);
     78                if(isthermal && meshtype==Mesh3DEnum){
    7979                        //Update Vertex Position after updating Thickness and Bed
    8080                        femmodel->SetCurrentConfiguration(MasstransportAnalysisEnum);
    … …  
    112112                femmodel->parameters->SetParam(save_results,SaveResultsEnum);
    113113
    114                 if(isthermal && dim==3){
     114                if(isthermal && meshtype==Mesh3DEnum){
    115115                        if(VerboseSolution()) _printf0_("   computing temperatures\n");
    116116                        #ifdef _HAVE_THERMAL_

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

    r16275 r16291  
    25732573IssmDouble Tria::MassFlux( IssmDouble* segment){
    25742574
    2575         int        dim;
     2575        int        meshtype;
    25762576        IssmDouble mass_flux=0.;
    25772577        IssmDouble xyz_list[NUMVERTICES][3];
    … …  
    26072607
    26082608        Input* thickness_input=inputs->GetInput(ThicknessEnum); _assert_(thickness_input);
    2609         this->parameters->FindParam(&dim,MeshDimensionEnum);
     2609        this->parameters->FindParam(&meshtype,MeshTypeEnum);
    26102610        Input* vx_input=NULL;
    26112611        Input* vy_input=NULL;
    2612         if(dim==2){
     2612        if(meshtype==Mesh2DhorizontalEnum){
    26132613                vx_input=inputs->GetInput(VxEnum); _assert_(vx_input);
    26142614                vy_input=inputs->GetInput(VyEnum); _assert_(vy_input);
    … …  
    62376237        /*Intermediaries */
    62386238        int        stabilization;
    6239         int        dim;
     6239        int        meshtype;
    62406240        IssmDouble Jdet,D_scalar,dt,h;
    62416241        IssmDouble vel,vx,vy,dvxdx,dvydy;
    … …  
    62566256        GetVerticesCoordinates(&xyz_list[0][0],vertices,NUMVERTICES);
    62576257        this->parameters->FindParam(&dt,TimesteppingTimeStepEnum);
    6258         this->parameters->FindParam(&dim,MeshDimensionEnum);
     6258        this->parameters->FindParam(&meshtype,MeshTypeEnum);
    62596259        this->parameters->FindParam(&stabilization,MasstransportStabilizationEnum);
    62606260        Input* vxaverage_input=NULL;
    62616261        Input* vyaverage_input=NULL;
    6262         if(dim==2){
     6262        if(meshtype==Mesh2DhorizontalEnum){
    62636263                vxaverage_input=inputs->GetInput(VxEnum); _assert_(vxaverage_input);
    62646264                vyaverage_input=inputs->GetInput(VyEnum); _assert_(vyaverage_input);
    … …  
    63556355
    63566356        /*Intermediaries */
    6357         int        dim;
     6357        int        meshtype;
    63586358        IssmDouble xyz_list[NUMVERTICES][3];
    63596359        IssmDouble Jdet,D_scalar,dt,vx,vy;
    … …  
    63726372        GetVerticesCoordinates(&xyz_list[0][0],vertices,NUMVERTICES);
    63736373        this->parameters->FindParam(&dt,TimesteppingTimeStepEnum);
    6374         this->parameters->FindParam(&dim,MeshDimensionEnum);
     6374        this->parameters->FindParam(&meshtype,MeshTypeEnum);
    63756375        Input* vxaverage_input=NULL;
    63766376        Input* vyaverage_input=NULL;
    6377         if(dim==2){
     6377        if(meshtype==Mesh2DhorizontalEnum){
    63786378                vxaverage_input=inputs->GetInput(VxEnum); _assert_(vxaverage_input);
    63796379                vyaverage_input=inputs->GetInput(VyEnum); _assert_(vyaverage_input);
    … …  
    68446844        /*Intermediaries */
    68456845        int        stabilization;
    6846         int        dim;
     6846        int        meshtype;
    68476847        IssmDouble Jdet,D_scalar,dt,h;
    68486848        IssmDouble vel,vx,vy,dvxdx,dvydy;
    … …  
    68636863        GetVerticesCoordinates(&xyz_list[0][0],vertices,NUMVERTICES);
    68646864        this->parameters->FindParam(&dt,TimesteppingTimeStepEnum);
    6865         this->parameters->FindParam(&dim,MeshDimensionEnum);
     6865        this->parameters->FindParam(&meshtype,MeshTypeEnum);
    68666866        this->parameters->FindParam(&stabilization,DamageStabilizationEnum);
    68676867        Input* vxaverage_input=NULL;
    68686868        Input* vyaverage_input=NULL;
    6869         if(dim==2){
     6869        if(meshtype==Mesh2DhorizontalEnum){
    68706870                vxaverage_input=inputs->GetInput(VxEnum); _assert_(vxaverage_input);
    68716871                vyaverage_input=inputs->GetInput(VyEnum); _assert_(vyaverage_input);
    … …  
    72687268
    72697269        /*Intermediaries */
    7270         int        stabilization,dim;
     7270        int        stabilization,meshtype;
    72717271        IssmDouble Jdet,vx,vy,dvxdx,dvydy,vel,h;
    72727272        IssmDouble D_scalar;
    … …  
    72877287        GetVerticesCoordinates(&xyz_list[0][0],vertices,NUMVERTICES);
    72887288        this->parameters->FindParam(&stabilization,BalancethicknessStabilizationEnum);
    7289         this->parameters->FindParam(&dim,MeshDimensionEnum);
     7289        this->parameters->FindParam(&meshtype,MeshTypeEnum);
    72907290        Input* vxaverage_input=NULL;
    72917291        Input* vyaverage_input=NULL;
    7292         if(dim==2){
     7292        if(meshtype==Mesh2DhorizontalEnum){
    72937293                vxaverage_input=inputs->GetInput(VxEnum); _assert_(vxaverage_input);
    72947294                vyaverage_input=inputs->GetInput(VyEnum); _assert_(vyaverage_input);
    … …  
    73767376
    73777377        /*Intermediaries*/
    7378         int        dim;
    73797378        IssmDouble vx,vy,D_scalar,Jdet;
    73807379        IssmDouble xyz_list[NUMVERTICES][3];
    … …  
    73927391        /*Retrieve all inputs and parameters*/
    73937392        GetVerticesCoordinates(&xyz_list[0][0],vertices,NUMVERTICES);
    7394         this->parameters->FindParam(&dim,MeshDimensionEnum);
    73957393        Input* vx_input=inputs->GetInput(VxEnum); _assert_(vx_input);
    73967394        Input* vy_input=inputs->GetInput(VyEnum); _assert_(vy_input);

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

    r16265 r16291  
    3030        this->my_vertices=NULL;
    3131
    32         this->dim=-1;
     32        this->meshtype=-1;
    3333        this->numberofvertices=-1;
    3434        this->numberofelements=-1;
    … …  
    7474        this->my_vertices = NULL;
    7575
    76         FetchData(&this->dim,MeshDimensionEnum);
     76        FetchData(&this->meshtype,MeshTypeEnum);
    7777        FetchData(&this->numberofvertices,MeshNumberofverticesEnum);
    7878        FetchData(&this->numberofelements,MeshNumberofelementsEnum);

  • issm/trunk-jpl/src/c/classes/IoModel.h

    r16253 r16291  
    3131
    3232                /*Mesh properties and connectivity tables*/
    33                 int   dim;
    34                 int   numberofvertices;
    35                 int   numberofelements;
    36                 int   numberoffaces;
    37                 int   numberofedges;
    38                 int  *elements;
    39                 int  *faces;
    40                 int  *edges;
    41                 int  *elementtoedgeconnectivity;
    42                 int  *singlenodetoelementconnectivity;
    43                 int  *numbernodetoelementconnectivity;
     33                int  meshtype;
     34                int  numberofvertices;
     35                int  numberofelements;
     36                int  numberoffaces;
     37                int  numberofedges;
     38                int *elements;
     39                int *faces;
     40                int *edges;
     41                int *elementtoedgeconnectivity;
     42                int *singlenodetoelementconnectivity;
     43                int *numbernodetoelementconnectivity;
    4444
    4545                /*Data to synchronize through low level object drivers: */

  • issm/trunk-jpl/src/c/classes/Materials/Matice.cpp

    r16233 r16291  
    701701
    702702        /*Intermediaries*/
    703         Element *element      = NULL;
    704         Parameters* parameters= NULL;
    705         int         dim;
     703        Element    *element    = NULL;
     704        Parameters *parameters = NULL;
     705        int         meshtype;
    706706
    707707        /*Recover element*/
    … …  
    730730                                                        parameters=((Penta*)(element))->parameters;
    731731                                                }
    732                                                 parameters->FindParam(&dim,MeshDimensionEnum);
    733                                                 if(dim==2){
     732                                                parameters->FindParam(&meshtype,MeshTypeEnum);
     733                                                if(meshtype==Mesh3DEnum){
    734734                                                        /*Duplicate rheology input: */
    735735                                                        this->inputs->AddInput(new TriaInput(MaterialsRheologyBbarEnum,values,P1Enum));
    … …  
    790790        if(control_analysis) iomodel->Constant(&num_control_type,InversionNumControlParametersEnum);
    791791
    792         if(iomodel->dim==2){
     792        if(iomodel->meshtype==Mesh2DhorizontalEnum){
    793793
    794794                /*Intermediaries*/
    … …  
    847847        /*if 3d*/
    848848        #ifdef _HAVE_3D_
    849         else if(iomodel->dim==3){
     849        else if(iomodel->meshtype==Mesh3DEnum){
    850850
    851851                /*Intermediaries*/

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

    r16233 r16291  
    5555                _assert_(sqrt( coord_system[0][0]*coord_system[0][0] + coord_system[1][0]*coord_system[1][0]) >1.e-4);
    5656
    57                 if(iomodel->dim==3){
     57                if(iomodel->meshtype==Mesh3DEnum){
    5858                        /*We have a  3d mesh, we may have collapsed elements, hence dead nodes. Freeze them out: */
    5959                        _assert_(iomodel->Data(MeshVertexonbedEnum));
    … …  
    9595                                analysis_type==HydrologyDCEfficientAnalysisEnum
    9696                                ){
    97                 if(iomodel->dim==3){
     97                if(iomodel->meshtype==Mesh3DEnum){
    9898                        /*On a 3d mesh, we may have collapsed elements, hence dead nodes. Freeze them out: */
    9999                        _assert_(iomodel->Data(MeshVertexonbedEnum));
    … …  
    104104        }
    105105        if(analysis_type==FreeSurfaceTopAnalysisEnum){
    106                 if(iomodel->dim==3){
     106                if(iomodel->meshtype==Mesh3DEnum){
    107107                        /*On a 3d mesh, we may have collapsed elements, hence dead nodes. Freeze them out: */
    108108                        _assert_(iomodel->Data(MeshVertexonsurfaceEnum));

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

    r16164 r16291  
    4848                        break;
    4949                case P1bubbleEnum:
    50                         switch(iomodel->dim){
    51                                 case 2: elementnbv = 3; break;
    52                                 case 3: elementnbv = 6; break;
     50                        switch(iomodel->meshtype){
     51                                case Mesh2DhorizontalEnum: elementnbv = 3; break;
     52                                case Mesh3DEnum:          elementnbv = 6; break;
    5353                                default: _error_("3d is the only supported dimension");
    5454                        }

  • issm/trunk-jpl/src/c/modules/MeshPartitionx/MeshPartitionx.h

    r15428 r16291  
    1111template <class doubletype>
    1212int MeshPartitionx(int** pepart, int** pnpart, int numberofelements,int numberofnodes,int* elements,
    13                 int numberofelements2d,int numberofnodes2d,doubletype* elements2d,int numlayers,int elements_width, int dim,int num_procs){
     13                int numberofelements2d,int numberofnodes2d,doubletype* elements2d,int numlayers,int elements_width, int meshtype,int num_procs){
    1414
    1515        int noerr=1;
    … …  
    3131        int  edgecut=1;
    3232
    33         if(dim==2){
    34                 epart=xNew<int>(numberofelements);
    35                 npart=xNew<int>(numberofnodes);
    36                 index=xNew<int>(elements_width*numberofelements);
    37                 for (i=0;i<numberofelements;i++){
    38                         for (j=0;j<elements_width;j++){
    39                                 *(index+elements_width*i+j)=(*(elements+elements_width*i+j))-1; //-1 for C indexing in Metis
     33        switch(meshtype){
     34                case Mesh2DhorizontalEnum:
     35                        epart=xNew<int>(numberofelements);
     36                        npart=xNew<int>(numberofnodes);
     37                        index=xNew<int>(elements_width*numberofelements);
     38                        for (i=0;i<numberofelements;i++){
     39                                for (j=0;j<elements_width;j++){
     40                                        *(index+elements_width*i+j)=(*(elements+elements_width*i+j))-1; //-1 for C indexing in Metis
     41                                }
    4042                        }
    41                 }
    4243
    43                 /*Partition using Metis:*/
    44                 if (num_procs>1){
    45                         #ifdef _HAVE_METIS_
    46                         METIS_PartMeshNodalPatch(&numberofelements,&numberofnodes, index, &etype, &numflag, &num_procs, &edgecut, epart, npart);
    47                         #else
    48                         _error_("metis has not beed installed. Cannot run with more than 1 cpu");
    49                         #endif
    50                 }
    51                 else if (num_procs==1){
    52                         /*METIS does not know how to deal with one cpu only!*/
    53                         for (i=0;i<numberofelements;i++) epart[i]=0;
    54                         for (i=0;i<numberofnodes;i++)    npart[i]=0;
    55                 }
    56                 else _error_("At least one processor is required");
    57         }
    58         else{
    59                 /*We have a 3d mesh, made of a regularly extruded 2d mesh. We first partition the 2d mesh, then we extrude the partition: */
     44                        /*Partition using Metis:*/
     45                        if (num_procs>1){
     46#ifdef _HAVE_METIS_
     47                                METIS_PartMeshNodalPatch(&numberofelements,&numberofnodes, index, &etype, &numflag, &num_procs, &edgecut, epart, npart);
     48#else
     49                                _error_("metis has not beed installed. Cannot run with more than 1 cpu");
     50#endif
     51                        }
     52                        else if (num_procs==1){
     53                                /*METIS does not know how to deal with one cpu only!*/
     54                                for (i=0;i<numberofelements;i++) epart[i]=0;
     55                                for (i=0;i<numberofnodes;i++)    npart[i]=0;
     56                        }
     57                        else _error_("At least one processor is required");
     58                        break;
     59                case Mesh3DEnum:
     60                        /*We have a 3d mesh, made of a regularly extruded 2d mesh. We first partition the 2d mesh, then we extrude the partition: */
    6061
    61                 /*First build concatenated 2d mesh  from 2d_coll and 2d_noncoll: */
    62                 epart2d=xNew<int>(numberofelements2d);
    63                 npart2d=xNew<int>(numberofnodes2d);
    64                 index2d=xNew<int>(3*numberofelements2d);
     62                        /*First build concatenated 2d mesh  from 2d_coll and 2d_noncoll: */
     63                        epart2d=xNew<int>(numberofelements2d);
     64                        npart2d=xNew<int>(numberofnodes2d);
     65                        index2d=xNew<int>(3*numberofelements2d);
    6566
    66                 for (i=0;i<numberofelements2d;i++){
    67                         for (j=0;j<3;j++){
    68                                 *(index2d+3*i+j)=reCast<int>(*(elements2d+3*i+j))-1; //-1 for C indexing in Metis
     67                        for (i=0;i<numberofelements2d;i++){
     68                                for (j=0;j<3;j++){
     69                                        *(index2d+3*i+j)=reCast<int>(*(elements2d+3*i+j))-1; //-1 for C indexing in Metis
     70                                }
    6971                        }
    70                 }
    7172
    72                 /*Partition using Metis:*/
    73                 if (num_procs>1){
    74                         #ifdef _HAVE_METIS_
    75                         METIS_PartMeshNodalPatch(&numberofelements2d,&numberofnodes2d, index2d, &etype2d, &numflag, &num_procs, &edgecut, epart2d, npart2d);
    76                         #else
    77                         _error_("metis has not beed installed. Cannot run with more than 1 cpu");
    78                         #endif
    79                 }
    80                 else if (num_procs==1){
    81                         /*METIS does not know how to deal with one cpu only!*/
    82                         for (i=0;i<numberofelements2d;i++) epart2d[i]=0;
    83                         for (i=0;i<numberofnodes2d;i++)    npart2d[i]=0;
    84                 }
    85                 else _error_("At least one processor is required");
     73                        /*Partition using Metis:*/
     74                        if (num_procs>1){
     75#ifdef _HAVE_METIS_
     76                                METIS_PartMeshNodalPatch(&numberofelements2d,&numberofnodes2d, index2d, &etype2d, &numflag, &num_procs, &edgecut, epart2d, npart2d);
     77#else
     78                                _error_("metis has not beed installed. Cannot run with more than 1 cpu");
     79#endif
     80                        }
     81                        else if (num_procs==1){
     82                                /*METIS does not know how to deal with one cpu only!*/
     83                                for (i=0;i<numberofelements2d;i++) epart2d[i]=0;
     84                                for (i=0;i<numberofnodes2d;i++)    npart2d[i]=0;
     85                        }
     86                        else _error_("At least one processor is required");
    8687
    87                 /*Extrude epart2d to epart, using numlayers: */
    88                 epart=xNew<int>(numberofelements);
     88                        /*Extrude epart2d to epart, using numlayers: */
     89                        epart=xNew<int>(numberofelements);
    8990
    90                 count=0;
    91                 for(i=0;i<(numlayers-1);i++){
    92                         for(j=0;j<numberofelements2d;j++){
    93                                 epart[count]=epart2d[j];
    94                                 count++;
     91                        count=0;
     92                        for(i=0;i<(numlayers-1);i++){
     93                                for(j=0;j<numberofelements2d;j++){
     94                                        epart[count]=epart2d[j];
     95                                        count++;
     96                                }
    9597                        }
    96                 }
    9798
    98                 /*Extrude npart2d to npart, using numlayers: */
    99                 npart=xNew<int>(numberofnodes);
     99                        /*Extrude npart2d to npart, using numlayers: */
     100                        npart=xNew<int>(numberofnodes);
    100101
    101                 count=0;
    102                 for(i=0;i<(numlayers);i++){
    103                         for(j=0;j<numberofnodes2d;j++){
    104                                 npart[count]=npart2d[j];
    105                                 count++;
     102                        count=0;
     103                        for(i=0;i<(numlayers);i++){
     104                                for(j=0;j<numberofnodes2d;j++){
     105                                        npart[count]=npart2d[j];
     106                                        count++;
     107                                }
    106108                        }
    107                 }
     109                        break;
     110                default:
     111                        _error_("mesh type "<<EnumToStringx(meshtype)<<" not supported yet");
    108112        }
    109113

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

    r16290 r16291  
    1616
    1717        /*Check in 3d*/
    18         if(stabilization==3 && iomodel->dim==3) _error_("DG 3d not implemented yet");
     18        if(stabilization==3 && iomodel->meshtype==Mesh3DEnum) _error_("DG 3d not implemented yet");
    1919
    2020        /*First fetch data: */
    21         iomodel->FetchData(2,MeshVertexonbedEnum,MeshVertexonsurfaceEnum);
     21        if(iomodel->meshtype==Mesh3DEnum) iomodel->FetchData(2,MeshVertexonbedEnum,MeshVertexonsurfaceEnum);
    2222        if(stabilization!=3){
    2323                CreateNodes(pnodes,iomodel,BalancethicknessAnalysisEnum,P1Enum);

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

    r15986 r16291  
    4242        iomodel->FetchDataToInput(elements,BalancethicknessThickeningRateEnum);
    4343
    44         if(iomodel->dim==3){
     44        if(iomodel->meshtype==Mesh3DEnum){
    4545                iomodel->FetchDataToInput(elements,MeshElementonbedEnum);
    4646                iomodel->FetchDataToInput(elements,MeshElementonsurfaceEnum);

  • issm/trunk-jpl/src/c/modules/ModelProcessorx/Balancevelocity/CreateNodesBalancevelocity.cpp

    r16007 r16291  
    1212
    1313        /*Check in 3d*/
    14         if(iomodel->dim==3) _error_("DG 3d not implemented yet");
     14        if(iomodel->meshtype==Mesh3DEnum) _error_("DG 3d not implemented yet");
    1515
    1616        /*First fetch data: */

  • issm/trunk-jpl/src/c/modules/ModelProcessorx/Balancevelocity/UpdateElementsBalancevelocity.cpp

    r16007 r16291  
    3131        iomodel->FetchDataToInput(elements,BalancethicknessThickeningRateEnum);
    3232
    33         if(iomodel->dim==3){
     33        if(iomodel->meshtype==Mesh3DEnum){
    3434                iomodel->FetchDataToInput(elements,MeshElementonbedEnum);
    3535                iomodel->FetchDataToInput(elements,MeshElementonsurfaceEnum);

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

    r16290 r16291  
    1111void    CreateNodesBedSlope(Nodes** pnodes, IoModel* iomodel){
    1212
    13         iomodel->FetchData(2,MeshVertexonbedEnum,MeshVertexonsurfaceEnum);
     13        if(iomodel->meshtype==Mesh3DEnum) iomodel->FetchData(2,MeshVertexonbedEnum,MeshVertexonsurfaceEnum);
    1414        CreateNodes(pnodes,iomodel,BedSlopeAnalysisEnum,P1Enum);
    1515        iomodel->DeleteData(2,MeshVertexonbedEnum,MeshVertexonsurfaceEnum);

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

    r15941 r16291  
    2424        iomodel->FetchDataToInput(elements,BedEnum);
    2525        iomodel->FetchDataToInput(elements,MaskIceLevelsetEnum);
    26         if(iomodel->dim==3){
     26        if(iomodel->meshtype==Mesh3DEnum){
    2727                iomodel->FetchDataToInput(elements,MeshElementonbedEnum);
    2828                iomodel->FetchDataToInput(elements,MeshElementonsurfaceEnum);

  • issm/trunk-jpl/src/c/modules/ModelProcessorx/CreateEdges.cpp

    r15723 r16291  
    2323
    2424        /*Mesh dependent variables*/
    25         if(iomodel->dim==2){
     25        if(iomodel->meshtype==Mesh2DhorizontalEnum){
    2626                elementnbv = 3;
    2727                elementnbe = 3;
    … …  
    3232                elementedges[2*2+0] = 0; elementedges[2*2+1] = 1; elementedges_markers[2] = 1;
    3333        }
    34         else if(iomodel->dim==3){
     34        else if(iomodel->meshtype==Mesh3DEnum){
    3535                elementnbv = 6;
    3636                elementnbe = 9;

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

    r16167 r16291  
    3535
    3636        #ifdef _HAVE_3D_
    37         if(iomodel->dim==3)iomodel->FetchData(2,MeshUpperelementsEnum,MeshLowerelementsEnum);
     37        if(iomodel->meshtype==Mesh3DEnum)iomodel->FetchData(2,MeshUpperelementsEnum,MeshLowerelementsEnum);
    3838        #endif
    3939        if(control_analysis)iomodel->FetchData(3,InversionControlParametersEnum,InversionMinParametersEnum,InversionMaxParametersEnum);
    … …  
    4444
    4545                        /*Create and add tria element to elements dataset: */
    46                         if(iomodel->dim==2) elements->AddObject(new Tria(i+1,i,i,iomodel,nummodels));
     46                        if(iomodel->meshtype==Mesh2DhorizontalEnum) elements->AddObject(new Tria(i+1,i,i,iomodel,nummodels));
    4747                #ifdef _HAVE_3D_
    4848                        else       elements->AddObject(new Penta(i+1,i,i,iomodel,nummodels));
    … …  
    5757                        for (i=0;i<iomodel->numberofelements;i++) if(iomodel->my_elements[i]) materials->AddObject(new Matice(i+1,i,iomodel));
    5858                        if(dakota_analysis){
    59                                 if(iomodel->dim==2) materials->InputDuplicate(MaterialsRheologyBbarEnum,QmuMaterialsRheologyBEnum);
     59                                if(iomodel->meshtype==Mesh2DhorizontalEnum) materials->InputDuplicate(MaterialsRheologyBbarEnum,QmuMaterialsRheologyBEnum);
    6060           #ifdef _HAVE_3D_
    6161                                else       materials->InputDuplicate(MaterialsRheologyBEnum,QmuMaterialsRheologyBEnum);

  • issm/trunk-jpl/src/c/modules/ModelProcessorx/CreateFaces.cpp

    r16218 r16291  
    1212
    1313        /*Check Iomodel properties*/
    14         if(iomodel->dim!=2)             _error_("only 2d model are supported");
     14        if(iomodel->meshtype!=Mesh2DhorizontalEnum)             _error_("only 2d model are supported");
    1515        if(iomodel->numberofvertices<3) _error_("not enough elements in mesh");
    1616        _assert_(iomodel->elements);

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

    r15428 r16291  
    3636
    3737        /*Get element width (3 or 6)*/
    38         if(iomodel->dim==2){
     38        if(iomodel->meshtype==Mesh2DhorizontalEnum){
    3939                elementswidth=3;
    4040        }

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

    r16272 r16291  
    1919
    2020        int         i,j,m,k;
    21         int         numoutputs;
     21        int         numoutputs,meshtype;
    2222        Parameters *parameters       = NULL;
    2323        IssmDouble *requestedoutputs = NULL;
    … …  
    4545
    4646        /*Copy some constants from iomodel */
    47         parameters->AddObject(iomodel->CopyConstantObject(MeshDimensionEnum));
     47        parameters->AddObject(iomodel->CopyConstantObject(MeshTypeEnum));
    4848        parameters->AddObject(iomodel->CopyConstantObject(SettingsOutputFrequencyEnum));
    4949        parameters->AddObject(iomodel->CopyConstantObject(SteadystateReltolEnum));
    … …  
    7474        parameters->AddObject(iomodel->CopyConstantObject(MeshNumberofelementsEnum));
    7575        parameters->AddObject(iomodel->CopyConstantObject(MeshNumberofverticesEnum));
    76         parameters->AddObject(iomodel->CopyConstantObject(MeshNumberoflayersEnum));
    7776        parameters->AddObject(iomodel->CopyConstantObject(SettingsIoGatherEnum));
    7877        parameters->AddObject(iomodel->CopyConstantObject(SettingsResultsAsPatchesEnum));
    … …  
    9493        parameters->AddObject(iomodel->CopyConstantObject(SurfaceforcingsIssmbgradientsEnum));
    9594        parameters->AddObject(iomodel->CopyConstantObject(GiaCrossSectionShapeEnum));
    96        
     95
     96        /*For stress balance only*/
     97        if(iomodel->meshtype==Mesh3DEnum)
     98         parameters->AddObject(iomodel->CopyConstantObject(MeshNumberoflayersEnum));
     99
    97100        iomodel->Constant(&ispdd,SurfaceforcingsIspddEnum);
    98101        if(ispdd){

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

    r15435 r16291  
    3030
    3131        /*Get element width (3 or 6)*/
    32         if(iomodel->dim==2){
     32        if(iomodel->meshtype==Mesh2DhorizontalEnum){
    3333                elementswidth=3;
    3434        }

  • issm/trunk-jpl/src/c/modules/ModelProcessorx/EdgesPartitioning.cpp

    r15611 r16291  
    1818
    1919        /*Mesh dependent variables*/
    20         if(iomodel->dim==2){
     20        if(iomodel->meshtype==Mesh2DhorizontalEnum){
    2121                elementnbe = 3;
    2222        }
    23         else if(iomodel->dim==3){
     23        else if(iomodel->meshtype==Mesh3DEnum){
    2424                elementnbe = 9;
    2525        }

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

    r15771 r16291  
    4545
    4646        /*Fetch parameters: */
    47         iomodel->Constant(&numberofelements2d,MeshNumberofelements2dEnum);
    48         iomodel->Constant(&numberofvertices2d,MeshNumberofvertices2dEnum);
    49         iomodel->Constant(&numlayers,MeshNumberoflayersEnum);
     47
    5048        iomodel->Constant(&numrifts,RiftsNumriftsEnum);
    5149
    … …  
    5553        /*Number of vertices per elements, needed to correctly retrieve data: */
    5654        /*Determine parallel partitioning of elements: we use Metis for now. First load the data, then partition*/
    57         if(iomodel->dim==2){
    58                 elements_width=3; //tria elements
    59         }
    60         else{
    61                 elements_width=6; //penta elements
    62                 iomodel->FetchData(&elements2d,NULL,NULL,MeshElements2dEnum);
     55        switch(iomodel->meshtype){
     56                case Mesh2DhorizontalEnum:
     57                        elements_width=3;
     58                        numberofelements2d = 0;
     59                        numberofvertices2d = 0;
     60                        numlayers          = 0;
     61                        break;
     62                case Mesh3DEnum:
     63                        elements_width=6; //penta elements
     64                        iomodel->FetchData(&elements2d,NULL,NULL,MeshElements2dEnum);
     65                        iomodel->Constant(&numberofelements2d,MeshNumberofelements2dEnum);
     66                        iomodel->Constant(&numberofvertices2d,MeshNumberofvertices2dEnum);
     67                        iomodel->Constant(&numlayers,MeshNumberoflayersEnum);
     68                        break;
     69                default:
     70                        _error_("mesh not supported yet");
    6371        }
    6472
    65         MeshPartitionx(&epart,&npart,iomodel->numberofelements,iomodel->numberofvertices,iomodel->elements,numberofelements2d,numberofvertices2d,elements2d,numlayers,elements_width,iomodel->dim,num_procs);
     73        MeshPartitionx(&epart,&npart,iomodel->numberofelements,iomodel->numberofvertices,iomodel->elements,numberofelements2d,numberofvertices2d,elements2d,numlayers,elements_width,iomodel->meshtype,num_procs);
    6674
    6775        /*Free elements2d: */

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

    r16200 r16291  
    3030
    3131        /*return if 2d mesh*/
    32         if(iomodel->dim==2) return;
     32        if(iomodel->meshtype==Mesh2DhorizontalEnum) return;
    3333
    3434        /*Fetch data: */

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

    r16290 r16291  
    1111void    CreateNodesEnthalpy(Nodes** pnodes, IoModel* iomodel){
    1212
    13         iomodel->FetchData(2,MeshVertexonbedEnum,MeshVertexonsurfaceEnum);
     13        if(iomodel->meshtype==Mesh3DEnum) iomodel->FetchData(2,MeshVertexonbedEnum,MeshVertexonsurfaceEnum);
    1414        CreateNodes(pnodes,iomodel,EnthalpyAnalysisEnum,P1Enum);
    1515        iomodel->DeleteData(2,MeshVertexonbedEnum,MeshVertexonsurfaceEnum);

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

    r16218 r16291  
    1313
    1414        /*Now, is the model 3d? otherwise, do nothing: */
    15         if(iomodel->dim==2)return;
     15        if(iomodel->meshtype==Mesh2DhorizontalEnum)return;
    1616
    1717        /*Fetch data needed: */

  • issm/trunk-jpl/src/c/modules/ModelProcessorx/FacesPartitioning.cpp

    r15611 r16291  
    1515
    1616        /*Check Iomodel properties*/
    17         if(iomodel->dim!=2) _error_("only 2d model are supported");
     17        if(iomodel->meshtype!=Mesh2DhorizontalEnum) _error_("only 2d model are supported");
    1818
    1919        /*Get faces and elements*/

  • issm/trunk-jpl/src/c/modules/ModelProcessorx/FreeSurfaceBase/CreateNodesFreeSurfaceBase.cpp

    r16290 r16291  
    1212
    1313        /*Create Nodes either DG or CG depending on stabilization*/
    14         iomodel->FetchData(2,MeshVertexonbedEnum,MeshVertexonsurfaceEnum);
     14        if(iomodel->meshtype==Mesh3DEnum) iomodel->FetchData(2,MeshVertexonbedEnum,MeshVertexonsurfaceEnum);
    1515        CreateNodes(pnodes,iomodel,FreeSurfaceBaseAnalysisEnum,P1Enum);
    1616        iomodel->DeleteData(2,MeshVertexonbedEnum,MeshVertexonsurfaceEnum);

  • issm/trunk-jpl/src/c/modules/ModelProcessorx/FreeSurfaceBase/UpdateElementsFreeSurfaceBase.cpp

    r16218 r16291  
    1212
    1313        /*Now, is the model 3d? otherwise, do nothing: */
    14         if (iomodel->dim==2)return;
     14        if (iomodel->meshtype==Mesh2DhorizontalEnum)return;
    1515
    1616        /*Finite element type*/

  • issm/trunk-jpl/src/c/modules/ModelProcessorx/FreeSurfaceTop/CreateNodesFreeSurfaceTop.cpp

    r16290 r16291  
    1212
    1313        /*Create Nodes either DG or CG depending on stabilization*/
    14         iomodel->FetchData(2,MeshVertexonbedEnum,MeshVertexonsurfaceEnum);
     14        if(iomodel->meshtype==Mesh3DEnum) iomodel->FetchData(2,MeshVertexonbedEnum,MeshVertexonsurfaceEnum);
    1515        CreateNodes(pnodes,iomodel,FreeSurfaceTopAnalysisEnum,P1Enum);
    1616        iomodel->DeleteData(2,MeshVertexonbedEnum,MeshVertexonsurfaceEnum);

  • issm/trunk-jpl/src/c/modules/ModelProcessorx/FreeSurfaceTop/UpdateElementsFreeSurfaceTop.cpp

    r16218 r16291  
    1212
    1313        /*Now, is the model 3d? otherwise, do nothing: */
    14         if (iomodel->dim==2)return;
     14        if (iomodel->meshtype==Mesh2DhorizontalEnum)return;
    1515
    1616        int finiteelement = P1Enum;

  • issm/trunk-jpl/src/c/modules/ModelProcessorx/HydrologyDCInefficient/CreateLoadsHydrologyDCInefficient.cpp

    r15643 r16291  
    2222        CreateSingleNodeToElementConnectivity(iomodel);
    2323        for(int i=0;i<iomodel->numberofvertices;i++){
    24                 if (iomodel->dim==3){
     24                if (iomodel->meshtype==Mesh3DEnum){
    2525                        /*keep only this partition's nodes:*/
    2626                        if((iomodel->my_vertices[i]==1)){

  • issm/trunk-jpl/src/c/modules/ModelProcessorx/HydrologyDCInefficient/CreateNodesHydrologyDCInefficient.cpp

    r16290 r16291  
    1818        if(hydrology_model!=HydrologydcEnum) return;
    1919
    20         iomodel->FetchData(2,MeshVertexonbedEnum,MeshVertexonsurfaceEnum);
     20        if(iomodel->meshtype==Mesh3DEnum) iomodel->FetchData(2,MeshVertexonbedEnum,MeshVertexonsurfaceEnum);
    2121        CreateNodes(pnodes,iomodel,HydrologyDCInefficientAnalysisEnum,P1Enum);
    2222        iomodel->DeleteData(2,MeshVertexonbedEnum,MeshVertexonsurfaceEnum);

  • issm/trunk-jpl/src/c/modules/ModelProcessorx/HydrologyShreve/CreateNodesHydrologyShreve.cpp

    r16290 r16291  
    1818        if(hydrology_model!=HydrologyshreveEnum) return;
    1919
    20         iomodel->FetchData(2,MeshVertexonbedEnum,MeshVertexonsurfaceEnum);
     20        if(iomodel->meshtype==Mesh3DEnum) iomodel->FetchData(2,MeshVertexonbedEnum,MeshVertexonsurfaceEnum);
    2121        CreateNodes(pnodes,iomodel,HydrologyShreveAnalysisEnum,P1Enum);
    2222        iomodel->DeleteData(2,MeshVertexonbedEnum,MeshVertexonsurfaceEnum);

  • issm/trunk-jpl/src/c/modules/ModelProcessorx/Masstransport/CreateNodesMasstransport.cpp

    r16290 r16291  
    1616
    1717        /*Check in 3d*/
    18         if(stabilization==3 && iomodel->dim==3) _error_("DG 3d not implemented yet");
     18        if(stabilization==3 && iomodel->meshtype==Mesh3DEnum) _error_("DG 3d not implemented yet");
    1919
    2020        /*Create Nodes either DG or CG depending on stabilization*/
    21         iomodel->FetchData(2,MeshVertexonbedEnum,MeshVertexonsurfaceEnum);
     21        if(iomodel->meshtype==Mesh3DEnum) iomodel->FetchData(2,MeshVertexonbedEnum,MeshVertexonsurfaceEnum);
    2222        if(stabilization!=3){
    2323                CreateNodes(pnodes,iomodel,MasstransportAnalysisEnum,P1Enum);

  • issm/trunk-jpl/src/c/modules/ModelProcessorx/Masstransport/UpdateElementsMasstransport.cpp

    r16218 r16291  
    6464        }
    6565
    66         if(iomodel->dim==3){
     66        if(iomodel->meshtype==Mesh3DEnum){
    6767                iomodel->FetchDataToInput(elements,MeshElementonbedEnum);
    6868                iomodel->FetchDataToInput(elements,MeshElementonsurfaceEnum);

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

    r15465 r16291  
    1010
    1111        /*if 2d: Error*/
    12         if(iomodel->dim==2) _error_("2d meshes not supported yet");
     12        if(iomodel->meshtype==Mesh2DhorizontalEnum) _error_("2d meshes not supported yet");
    1313
    1414        /*Recover pointer: */

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

    r16290 r16291  
    1111void    CreateNodesMelting(Nodes** pnodes, IoModel* iomodel){
    1212
    13         iomodel->FetchData(2,MeshVertexonbedEnum,MeshVertexonsurfaceEnum);
     13        if(iomodel->meshtype==Mesh3DEnum) iomodel->FetchData(2,MeshVertexonbedEnum,MeshVertexonsurfaceEnum);
    1414        CreateNodes(pnodes,iomodel,MeltingAnalysisEnum,P1Enum);
    1515        iomodel->DeleteData(2,MeshVertexonbedEnum,MeshVertexonsurfaceEnum);

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

    r15986 r16291  
    1212
    1313        /*Now, is the model 3d? otherwise, do nothing: */
    14         if(iomodel->dim==2)return;
     14        if(iomodel->meshtype==Mesh2DhorizontalEnum)return;
    1515
    1616        /*Update elements: */

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

    r16142 r16291  
    4747
    4848                /*Hack for trasient runs (FIXME: to be improved)*/
    49                 if(solution_type==TransientSolutionEnum && analysis_type==ThermalAnalysisEnum  && iomodel->dim==2) continue;
    50                 if(solution_type==TransientSolutionEnum && analysis_type==MeltingAnalysisEnum  && iomodel->dim==2) continue;
    51                 if(solution_type==TransientSolutionEnum && analysis_type==EnthalpyAnalysisEnum && iomodel->dim==2) continue;
     49                if(solution_type==TransientSolutionEnum && analysis_type==ThermalAnalysisEnum  && iomodel->meshtype==Mesh2DhorizontalEnum) continue;
     50                if(solution_type==TransientSolutionEnum && analysis_type==MeltingAnalysisEnum  && iomodel->meshtype==Mesh2DhorizontalEnum) continue;
     51                if(solution_type==TransientSolutionEnum && analysis_type==EnthalpyAnalysisEnum && iomodel->meshtype==Mesh2DhorizontalEnum) continue;
    5252                if(solution_type==TransientSolutionEnum && analysis_type==ThermalAnalysisEnum && isthermal==false) continue;
    5353                if(solution_type==TransientSolutionEnum && analysis_type==MeltingAnalysisEnum && isthermal==false) continue;

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

    r16200 r16291  
    6565
    6666        /*First: add all the nodes of all the elements belonging to this cpu*/
    67         if(iomodel->dim==2){
     67        if(iomodel->meshtype==Mesh2DhorizontalEnum){
    6868                for (i=0;i<iomodel->numberofelements;i++){
    6969                        if (my_elements[i]){

  • issm/trunk-jpl/src/c/modules/ModelProcessorx/Stressbalance/CreateConstraintsStressbalance.cpp

    r16218 r16291  
    161161        iomodel->FetchData(&spcvz,&Mz,&Nz,StressbalanceSpcvzEnum);
    162162        iomodel->FetchData(&nodeonSSA,NULL,NULL,FlowequationBorderSSAEnum);
    163         if(iomodel->dim==3)iomodel->FetchData(&nodeonHO,NULL,NULL,FlowequationBorderHOEnum);
    164         if(iomodel->dim==3)iomodel->FetchData(&nodeonFS,NULL,NULL,FlowequationBorderFSEnum);
    165         if(iomodel->dim==3)iomodel->FetchData(&nodeonbed,NULL,NULL,MeshVertexonbedEnum);
    166         if(iomodel->dim==3)iomodel->FetchData(&groundedice_ls,NULL,NULL,MaskGroundediceLevelsetEnum);
     163        if(iomodel->meshtype==Mesh3DEnum)iomodel->FetchData(&nodeonHO,NULL,NULL,FlowequationBorderHOEnum);
     164        if(iomodel->meshtype==Mesh3DEnum)iomodel->FetchData(&nodeonFS,NULL,NULL,FlowequationBorderFSEnum);
     165        if(iomodel->meshtype==Mesh3DEnum)iomodel->FetchData(&nodeonbed,NULL,NULL,MeshVertexonbedEnum);
     166        if(iomodel->meshtype==Mesh3DEnum)iomodel->FetchData(&groundedice_ls,NULL,NULL,MaskGroundediceLevelsetEnum);
    167167        iomodel->FetchData(&vertices_type,NULL,NULL,FlowequationVertexEquationEnum);
    168168        iomodel->FetchData(&surface,NULL,NULL,SurfaceEnum);
    … …  
    385385
    386386                        /*Constraint at the bedrock interface (v.n = vz = 0) (Coordinates will be updated according to the bed slope)*/
    387                         if (iomodel->dim==3) if(nodeonbed[i]>0. && groundedice_ls[i]>=0. && nodeonFS[i]>0.){
     387                        if (iomodel->meshtype==Mesh3DEnum) if(nodeonbed[i]>0. && groundedice_ls[i]>=0. && nodeonFS[i]>0.){
    388388                                 switch(reCast<int,IssmDouble>(vertices_type[i])){
    389389                                        case SSAFSApproximationEnum:
    … …  
    410410        iomodel->DeleteData(spcvz,StressbalanceSpcvzEnum);
    411411        iomodel->DeleteData(nodeonSSA,FlowequationBorderSSAEnum);
    412         if(iomodel->dim==3)iomodel->DeleteData(nodeonHO,FlowequationBorderHOEnum);
    413         if(iomodel->dim==3)iomodel->DeleteData(nodeonFS,FlowequationBorderFSEnum);
    414         if(iomodel->dim==3)iomodel->DeleteData(nodeonbed,MeshVertexonbedEnum);
    415         if(iomodel->dim==3)iomodel->DeleteData(groundedice_ls,MaskGroundediceLevelsetEnum);
     412        if(iomodel->meshtype==Mesh3DEnum)iomodel->DeleteData(nodeonHO,FlowequationBorderHOEnum);
     413        if(iomodel->meshtype==Mesh3DEnum)iomodel->DeleteData(nodeonFS,FlowequationBorderFSEnum);
     414        if(iomodel->meshtype==Mesh3DEnum)iomodel->DeleteData(nodeonbed,MeshVertexonbedEnum);
     415        if(iomodel->meshtype==Mesh3DEnum)iomodel->DeleteData(groundedice_ls,MaskGroundediceLevelsetEnum);
    416416        iomodel->DeleteData(vertices_type,FlowequationVertexEquationEnum);
    417417        iomodel->DeleteData(surface,SurfaceEnum);

  • issm/trunk-jpl/src/c/modules/ModelProcessorx/Stressbalance/CreateNodesStressbalance.cpp

    r16024 r16291  
    5050                        iomodel->Constant(&finiteelement,FlowequationFeFSEnum);
    5151                }
    52                 iomodel->FetchData(6,MeshVertexonbedEnum,MeshVertexonsurfaceEnum,FlowequationBorderSSAEnum,FlowequationBorderFSEnum,
    53                                         FlowequationVertexEquationEnum,StressbalanceReferentialEnum);
     52                iomodel->FetchData(3,FlowequationBorderSSAEnum,FlowequationVertexEquationEnum,StressbalanceReferentialEnum);
     53                if(iomodel->meshtype==Mesh3DEnum) iomodel->FetchData(3,MeshVertexonbedEnum,MeshVertexonsurfaceEnum,FlowequationBorderFSEnum);
    5454                CreateNodes(pnodes,iomodel,StressbalanceAnalysisEnum,finiteelement,approximation);
    5555                iomodel->DeleteData(6,MeshVertexonbedEnum,MeshVertexonsurfaceEnum,FlowequationBorderSSAEnum,FlowequationBorderFSEnum,

  • issm/trunk-jpl/src/c/modules/ModelProcessorx/Stressbalance/UpdateElementsStressbalance.cpp

    r16228 r16291  
    104104        iomodel->FetchDataToInput(elements,DamageDEnum);
    105105
    106         if(iomodel->dim==3){
     106        if(iomodel->meshtype==Mesh3DEnum){
    107107                iomodel->FetchDataToInput(elements,MeshElementonbedEnum);
    108108                iomodel->FetchDataToInput(elements,MeshElementonsurfaceEnum);

  • issm/trunk-jpl/src/c/modules/ModelProcessorx/StressbalanceVertical/CreateConstraintsStressbalanceVertical.cpp

    r15857 r16291  
    2121
    2222        /*return if 2d mesh*/
    23         if(iomodel->dim==2) return;
     23        if(iomodel->meshtype==Mesh2DhorizontalEnum) return;
    2424
    2525        /*Fetch data: */

  • issm/trunk-jpl/src/c/modules/ModelProcessorx/StressbalanceVertical/CreateNodesStressbalanceVertical.cpp

    r15986 r16291  
    1212
    1313        /*Now, is the flag macayaealHO on? otherwise, do nothing: */
    14         if(iomodel->dim==2) return;
     14        if(iomodel->meshtype==Mesh2DhorizontalEnum) return;
    1515
    1616        iomodel->FetchData(3,MeshVertexonbedEnum,MeshVertexonsurfaceEnum,FlowequationVertexEquationEnum);

  • issm/trunk-jpl/src/c/modules/ModelProcessorx/StressbalanceVertical/UpdateElementsStressbalanceVertical.cpp

    r16223 r16291  
    1212
    1313        /*Now, is the model 3d? otherwise, do nothing: */
    14         if (iomodel->dim==2)return;
     14        if (iomodel->meshtype==Mesh2DhorizontalEnum)return;
    1515
    1616        /*Update elements: */

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

    r16290 r16291  
    1111void    CreateNodesSurfaceSlope(Nodes** pnodes, IoModel* iomodel){
    1212
    13         iomodel->FetchData(2,MeshVertexonbedEnum,MeshVertexonsurfaceEnum);
     13        if(iomodel->meshtype==Mesh3DEnum) iomodel->FetchData(2,MeshVertexonbedEnum,MeshVertexonsurfaceEnum);
    1414        CreateNodes(pnodes,iomodel,SurfaceSlopeAnalysisEnum,P1Enum);
    1515        iomodel->DeleteData(2,MeshVertexonbedEnum,MeshVertexonsurfaceEnum);

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

    r15941 r16291  
    2424        iomodel->FetchDataToInput(elements,BedEnum);
    2525        iomodel->FetchDataToInput(elements,MaskIceLevelsetEnum);
    26         if(iomodel->dim==3){
     26        if(iomodel->meshtype==Mesh3DEnum){
    2727                iomodel->FetchDataToInput(elements,MeshElementonbedEnum);
    2828                iomodel->FetchDataToInput(elements,MeshElementonsurfaceEnum);

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

    r15484 r16291  
    1515
    1616        /*Only 3d mesh supported*/
    17         if(iomodel->dim==3){
     17        if(iomodel->meshtype==Mesh3DEnum){
    1818                IoModelToConstraintsx(constraints,iomodel,ThermalSpctemperatureEnum,ThermalAnalysisEnum,P1Enum);
    1919        }

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

    r15465 r16291  
    1212        Loads* loads=*ploads;
    1313
    14         if(iomodel->dim==2) _error_("2d meshes not supported yet");
     14        if(iomodel->meshtype==Mesh2DhorizontalEnum) _error_("2d meshes not supported yet");
    1515
    1616        /*create penalties for nodes: no node can have a temperature over the melting point*/

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

    r16290 r16291  
    1111void    CreateNodesThermal(Nodes** pnodes, IoModel* iomodel){
    1212
    13         iomodel->FetchData(2,MeshVertexonbedEnum,MeshVertexonsurfaceEnum);
     13        if(iomodel->meshtype==Mesh3DEnum) iomodel->FetchData(2,MeshVertexonbedEnum,MeshVertexonsurfaceEnum);
    1414        CreateNodes(pnodes,iomodel,ThermalAnalysisEnum,P1Enum);
    1515        iomodel->DeleteData(2,MeshVertexonbedEnum,MeshVertexonsurfaceEnum);

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

    r16218 r16291  
    1313
    1414        /*Now, is the model 3d? otherwise, do nothing: */
    15         if(iomodel->dim==2)return;
     15        if(iomodel->meshtype==Mesh2DhorizontalEnum)return;
    1616
    1717        /*Update elements: */

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

    r16275 r16291  
    183183        MaterialsMantleDensityEnum,
    184184        MeshAverageVertexConnectivityEnum,
    185         MeshDimensionEnum,
    186185        MeshElementonbedEnum,
    187186        MeshElementonsurfaceEnum,
    … …  
    200199        MeshYEnum,
    201200        MeshZEnum,
     201        MeshTypeEnum,
     202        Mesh2DhorizontalEnum,
     203        Mesh2DverticalEnum,
     204        Mesh3DEnum,
    202205        MiscellaneousNameEnum, //FIXME: only used by qmu, should not be marshalled (already in queueing script)
    203206        MasstransportHydrostaticAdjustmentEnum,

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

    r16275 r16291  
    191191                case MaterialsMantleDensityEnum : return "MaterialsMantleDensity";
    192192                case MeshAverageVertexConnectivityEnum : return "MeshAverageVertexConnectivity";
    193                 case MeshDimensionEnum : return "MeshDimension";
    194193                case MeshElementonbedEnum : return "MeshElementonbed";
    195194                case MeshElementonsurfaceEnum : return "MeshElementonsurface";
    … …  
    208207                case MeshYEnum : return "MeshY";
    209208                case MeshZEnum : return "MeshZ";
     209                case MeshTypeEnum : return "MeshType";
     210                case Mesh2DhorizontalEnum : return "Mesh2Dhorizontal";
     211                case Mesh2DverticalEnum : return "Mesh2Dvertical";
     212                case Mesh3DEnum : return "Mesh3D";
    210213                case MiscellaneousNameEnum : return "MiscellaneousName";
    211214                case MasstransportHydrostaticAdjustmentEnum : return "MasstransportHydrostaticAdjustment";

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

    r16275 r16291  
    194194              else if (strcmp(name,"MaterialsMantleDensity")==0) return MaterialsMantleDensityEnum;
    195195              else if (strcmp(name,"MeshAverageVertexConnectivity")==0) return MeshAverageVertexConnectivityEnum;
    196               else if (strcmp(name,"MeshDimension")==0) return MeshDimensionEnum;
    197196              else if (strcmp(name,"MeshElementonbed")==0) return MeshElementonbedEnum;
    198197              else if (strcmp(name,"MeshElementonsurface")==0) return MeshElementonsurfaceEnum;
    … …  
    211210              else if (strcmp(name,"MeshY")==0) return MeshYEnum;
    212211              else if (strcmp(name,"MeshZ")==0) return MeshZEnum;
     212              else if (strcmp(name,"MeshType")==0) return MeshTypeEnum;
     213              else if (strcmp(name,"Mesh2Dhorizontal")==0) return Mesh2DhorizontalEnum;
     214              else if (strcmp(name,"Mesh2Dvertical")==0) return Mesh2DverticalEnum;
     215              else if (strcmp(name,"Mesh3D")==0) return Mesh3DEnum;
    213216              else if (strcmp(name,"MiscellaneousName")==0) return MiscellaneousNameEnum;
    214217              else if (strcmp(name,"MasstransportHydrostaticAdjustment")==0) return MasstransportHydrostaticAdjustmentEnum;
    … …  
    257260              else if (strcmp(name,"SurfaceforcingsMassBalance")==0) return SurfaceforcingsMassBalanceEnum;
    258261              else if (strcmp(name,"SurfaceforcingsIspdd")==0) return SurfaceforcingsIspddEnum;
    259               else if (strcmp(name,"SurfaceforcingsDesfac")==0) return SurfaceforcingsDesfacEnum;
    260               else if (strcmp(name,"SurfaceforcingsS0p")==0) return SurfaceforcingsS0pEnum;
    261               else if (strcmp(name,"SurfaceforcingsIssmbgradients")==0) return SurfaceforcingsIssmbgradientsEnum;
    262262         else stage=3;
    263263   }
    264264   if(stage==3){
    265               if (strcmp(name,"SurfaceforcingsMonthlytemperatures")==0) return SurfaceforcingsMonthlytemperaturesEnum;
     265              if (strcmp(name,"SurfaceforcingsDesfac")==0) return SurfaceforcingsDesfacEnum;
     266              else if (strcmp(name,"SurfaceforcingsS0p")==0) return SurfaceforcingsS0pEnum;
     267              else if (strcmp(name,"SurfaceforcingsIssmbgradients")==0) return SurfaceforcingsIssmbgradientsEnum;
     268              else if (strcmp(name,"SurfaceforcingsMonthlytemperatures")==0) return SurfaceforcingsMonthlytemperaturesEnum;
    266269              else if (strcmp(name,"SurfaceforcingsHref")==0) return SurfaceforcingsHrefEnum;
    267270              else if (strcmp(name,"SurfaceforcingsSmbref")==0) return SurfaceforcingsSmbrefEnum;
    … …  
    380383              else if (strcmp(name,"Input")==0) return InputEnum;
    381384              else if (strcmp(name,"IntInput")==0) return IntInputEnum;
    382               else if (strcmp(name,"IntParam")==0) return IntParamEnum;
    383               else if (strcmp(name,"IntVecParam")==0) return IntVecParamEnum;
    384               else if (strcmp(name,"TransientParam")==0) return TransientParamEnum;
    385385         else stage=4;
    386386   }
    387387   if(stage==4){
    388               if (strcmp(name,"Matice")==0) return MaticeEnum;
     388              if (strcmp(name,"IntParam")==0) return IntParamEnum;
     389              else if (strcmp(name,"IntVecParam")==0) return IntVecParamEnum;
     390              else if (strcmp(name,"TransientParam")==0) return TransientParamEnum;
     391              else if (strcmp(name,"Matice")==0) return MaticeEnum;
    389392              else if (strcmp(name,"Matpar")==0) return MatparEnum;
    390393              else if (strcmp(name,"Node")==0) return NodeEnum;
    … …  
    503506              else if (strcmp(name,"StressTensorxz")==0) return StressTensorxzEnum;
    504507              else if (strcmp(name,"StressTensoryy")==0) return StressTensoryyEnum;
    505               else if (strcmp(name,"StressTensoryz")==0) return StressTensoryzEnum;
    506               else if (strcmp(name,"StressTensorzz")==0) return StressTensorzzEnum;
    507               else if (strcmp(name,"GiaCrossSectionShape")==0) return GiaCrossSectionShapeEnum;
    508508         else stage=5;
    509509   }
    510510   if(stage==5){
    511               if (strcmp(name,"GiadWdt")==0) return GiadWdtEnum;
     511              if (strcmp(name,"StressTensoryz")==0) return StressTensoryzEnum;
     512              else if (strcmp(name,"StressTensorzz")==0) return StressTensorzzEnum;
     513              else if (strcmp(name,"GiaCrossSectionShape")==0) return GiaCrossSectionShapeEnum;
     514              else if (strcmp(name,"GiadWdt")==0) return GiadWdtEnum;
    512515              else if (strcmp(name,"GiaW")==0) return GiaWEnum;
    513516              else if (strcmp(name,"P0")==0) return P0Enum;
Note: See TracChangeset for help on using the changeset viewer.