Changeset 15428


Ignore:
Timestamp:
07/04/13 10:44:52 (12 years ago)
Author:
Mathieu Morlighem
Message:

NEW: mesh properties (elements,dim,numberofvertices,...) are now Iomodel fields and fetch in the constructor. This cleans up ModelProcessor and will ease the implementation of quadratic elements

Location:
issm/trunk-jpl/src
Files:
59 edited

Legend:

Unmodified
Added
Removed

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

    r15372 r15428  
    5757        int* vertex_ids = xNew<int>(numvertices);
    5858        for(int i=0;i<numvertices;i++){
    59                 vertex_ids[i]=reCast<int>(iomodel->Data(MeshElementsEnum)[(element_id-1)*numvertices+i]);
     59                vertex_ids[i]=reCast<int>(iomodel->elements[(element_id-1)*numvertices+i]);
    6060        }
    6161

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

    r15425 r15428  
    13951395        TransientInput* transientinput=NULL;
    13961396
    1397         int    numberofvertices;
    1398         int    numberofelements;
    13991397        IssmDouble yts;
    14001398
    14011399        /*Fetch parameters: */
    1402         iomodel->Constant(&numberofvertices,MeshNumberofverticesEnum);
    1403         iomodel->Constant(&numberofelements,MeshNumberofelementsEnum);
    14041400        iomodel->Constant(&yts,ConstantsYtsEnum);
    14051401
    … …  
    14091405                /*Recover vertices ids needed to initialize inputs*/
    14101406                for(i=0;i<6;i++){
    1411                         _assert_(iomodel->Data(MeshElementsEnum));
    1412                         penta_vertex_ids[i]=reCast<int,IssmDouble>(iomodel->Data(MeshElementsEnum)[6*index+i]); //ids for vertices are in the elements array from Matlab
     1407                        _assert_(iomodel->elements);
     1408                        penta_vertex_ids[i]=iomodel->elements[6*index+i]; //ids for vertices are in the elements array from Matlab
    14131409                }
    14141410
    14151411                /*Are we in transient or static? */
    1416                 if(M==numberofvertices){
     1412                if(M==iomodel->numberofvertices){
    14171413
    14181414                        /*create input values: */
    … …  
    14221418                        this->inputs->AddInput(new PentaInput(vector_enum,nodeinputs,P1Enum));
    14231419                }
    1424                 else if(M==numberofvertices+1){
     1420                else if(M==iomodel->numberofvertices+1){
    14251421                        /*create transient input: */
    14261422                        for(t=0;t<N;t++){ //N is the number of times
    … …  
    14401436                        this->inputs->AddInput(transientinput);
    14411437                }
    1442                 else _error_("nodal vector is either numberofnodes (" << numberofvertices << "), or numberofnodes+1 long. Field provided is " << M << " long. Enum " << EnumToStringx(vector_enum));
     1438                else _error_("nodal vector is either numberofvertices (" << iomodel->numberofvertices << "), or numberofvertices+1 long. Field provided is " << M << " long. Enum " << EnumToStringx(vector_enum));
    14431439        }
    14441440        else if(vector_type==2){ //element vector
    14451441                /*Are we in transient or static? */
    1446                 if(M==numberofelements){
     1442                if(M==iomodel->numberofelements){
    14471443
    14481444                        /*static mode: create an input out of the element value: */
    … …  
    17341730        /*Checks if debuging*/
    17351731        /*{{{*/
    1736         _assert_(iomodel->Data(MeshElementsEnum));
     1732        _assert_(iomodel->elements);
    17371733        /*}}}*/
    17381734
    17391735        /*Recover vertices ids needed to initialize inputs*/
    17401736        for(i=0;i<6;i++){
    1741                 penta_vertex_ids[i]=reCast<int,IssmDouble>(iomodel->Data(MeshElementsEnum)[6*index+i]); //ids for vertices are in the elements array from Matlab
     1737                penta_vertex_ids[i]=iomodel->elements[6*index+i]; //ids for vertices are in the elements array from Matlab
    17421738        }
    17431739
    … …  
    29362932        /*Checks if debuging*/
    29372933        /*{{{*/
    2938         _assert_(iomodel->Data(MeshElementsEnum));
     2934        _assert_(iomodel->elements);
    29392935        /*}}}*/
    29402936
    … …  
    29512947
    29522948        /*Recover vertices ids needed to initialize inputs*/
    2953         for(i=0;i<6;i++) penta_vertex_ids[i]=reCast<int,IssmDouble>(iomodel->Data(MeshElementsEnum)[6*index+i]); //ids for vertices are in the elements array from Matlab
     2949        for(i=0;i<6;i++) penta_vertex_ids[i]=iomodel->elements[6*index+i]; //ids for vertices are in the elements array from Matlab
    29542950
    29552951        /*Recover nodes ids needed to initialize the node hook.*/
    … …  
    29572953                //go recover node ids, needed to initialize the node hook.
    29582954                //WARNING: We assume P1 elements here!!!!!
    2959                 penta_node_ids[i]=iomodel->nodecounter+reCast<int,IssmDouble>(iomodel->Data(MeshElementsEnum)[6*index+i]); //ids for vertices are in the elements array from Matlab
     2955                penta_node_ids[i]=iomodel->nodecounter+iomodel->elements[6*index+i]; //ids for vertices are in the elements array from Matlab
    29602956        }
    29612957

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

    r15407 r15428  
    13171317        /*Recover vertices ids needed to initialize inputs*/
    13181318        for(i=0;i<3;i++){
    1319                 tria_vertex_ids[i]=reCast<int>(iomodel->Data(MeshElementsEnum)[3*index+i]); //ids for vertices are in the elements array from Matlab
     1319                tria_vertex_ids[i]=reCast<int>(iomodel->elements[3*index+i]); //ids for vertices are in the elements array from Matlab
    13201320        }
    13211321
    … …  
    16511651        IssmDouble time;
    16521652        TransientInput* transientinput=NULL;
    1653         int    numberofvertices;
    1654         int    numberofelements;
    16551653        IssmDouble yts;
    16561654
    16571655        /*Fetch parameters: */
    1658         iomodel->Constant(&numberofvertices,MeshNumberofverticesEnum);
    1659         iomodel->Constant(&numberofelements,MeshNumberofelementsEnum);
    16601656        iomodel->Constant(&yts,ConstantsYtsEnum);
    16611657
    … …  
    16651661                /*Recover vertices ids needed to initialize inputs*/
    16661662                for(i=0;i<3;i++){
    1667                         _assert_(iomodel->Data(MeshElementsEnum));
    1668                         tria_vertex_ids[i]=reCast<int>(iomodel->Data(MeshElementsEnum)[3*index+i]); //ids for vertices are in the elements array from Matlab
     1663                        _assert_(iomodel->elements);
     1664                        tria_vertex_ids[i]=reCast<int>(iomodel->elements[3*index+i]); //ids for vertices are in the elements array from Matlab
    16691665                }
    16701666
    16711667                /*Are we in transient or static? */
    1672                 if(M==numberofvertices){
     1668                if(M==iomodel->numberofvertices){
    16731669
    16741670                        /*create input values: */
    … …  
    16781674                        this->inputs->AddInput(new TriaInput(vector_enum,nodeinputs,P1Enum));
    16791675                }
    1680                 else if(M==numberofvertices+1){
     1676                else if(M==iomodel->numberofvertices+1){
    16811677                        /*create transient input: */
    16821678                        for(t=0;t<N;t++){ //N is the number of times
    … …  
    16961692                        this->inputs->AddInput(transientinput);
    16971693                }
    1698                 else _error_("nodal vector is either numberofnodes or numberofnodes+1 long. Field provided (" << EnumToStringx(vector_enum) << ") is " << M << " long");
     1694                else _error_("nodal vector is either numberofvertices or numberofvertices+1 long. Field provided (" << EnumToStringx(vector_enum) << ") is " << M << " long");
    16991695        }
    17001696        else if(vector_type==2){ //element vector
    17011697                /*Are we in transient or static? */
    1702                 if(M==numberofelements){
     1698                if(M==iomodel->numberofelements){
    17031699
    17041700                        /*static mode: create an input out of the element value: */
    … …  
    22192215        /*Checks if debuging*/
    22202216        /*{{{*/
    2221         _assert_(iomodel->Data(MeshElementsEnum));
     2217        _assert_(iomodel->elements);
    22222218        /*}}}*/
    22232219
    … …  
    22412237        /*Recover vertices ids needed to initialize inputs*/
    22422238        for(i=0;i<3;i++){
    2243                 tria_vertex_ids[i]=reCast<int>(iomodel->Data(MeshElementsEnum)[3*index+i]); //ids for vertices are in the elements array from Matlab
     2239                tria_vertex_ids[i]=reCast<int>(iomodel->elements[3*index+i]); //ids for vertices are in the elements array from Matlab
    22442240        }
    22452241
    … …  
    22542250                /*Continuous Galerkin*/
    22552251                for(i=0;i<3;i++){
    2256                         tria_node_ids[i]=iomodel->nodecounter+reCast<int,IssmDouble>(*(iomodel->Data(MeshElementsEnum)+3*index+i)); //ids for vertices are in the elements array from Matlab
     2252                        tria_node_ids[i]=iomodel->nodecounter+reCast<int,IssmDouble>(*(iomodel->elements+3*index+i)); //ids for vertices are in the elements array from Matlab
    22572253                }
    22582254        }

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

    r15419 r15428  
    6969
    7070        FetchData(&this->dim,MeshDimensionEnum);
    71         this->elements=NULL;
     71        FetchData(&this->numberofvertices,MeshNumberofverticesEnum);
     72        FetchData(&this->numberofelements,MeshNumberofelementsEnum);
     73        FetchData(&this->elements,NULL,NULL,MeshElementsEnum);
    7274        this->edges=NULL;
    7375        this->singlenodetoelementconnectivity=NULL;
    … …  
    101103        xDelete<bool>(this->my_nodes);
    102104        xDelete<int>(this->my_vertices);
     105        xDelete<int>(this->elements);
     106        xDelete<int>(this->edges);
    103107        xDelete<int>(this->singlenodetoelementconnectivity);
    104108        xDelete<int>(this->numbernodetoelementconnectivity);

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

    r15419 r15428  
    3333                /*Mesh properties and connectivity tables*/
    3434                int   dim;
     35                int   numberofvertices;
     36                int   numberofelements;
    3537                int  *elements;
    3638                int  *edges;

  • issm/trunk-jpl/src/c/classes/Loads/Numericalflux.cpp

    r15373 r15428  
    9393                pos1=pos2=pos3=pos4=UNDEF;
    9494                for(j=0;j<3;j++){
    95                         if (iomodel->Data(MeshElementsEnum)[3*(e1-1)+j]==i1) pos1=j+1;
    96                         if (iomodel->Data(MeshElementsEnum)[3*(e1-1)+j]==i2) pos2=j+1;
    97                         if (iomodel->Data(MeshElementsEnum)[3*(e2-1)+j]==i1) pos3=j+1;
    98                         if (iomodel->Data(MeshElementsEnum)[3*(e2-1)+j]==i2) pos4=j+1;
     95                        if (iomodel->elements[3*(e1-1)+j]==i1) pos1=j+1;
     96                        if (iomodel->elements[3*(e1-1)+j]==i2) pos2=j+1;
     97                        if (iomodel->elements[3*(e2-1)+j]==i1) pos3=j+1;
     98                        if (iomodel->elements[3*(e2-1)+j]==i2) pos4=j+1;
    9999                }
    100100                _assert_(pos1!=UNDEF && pos2!=UNDEF && pos3!=UNDEF && pos4!=UNDEF);
    … …  
    112112                pos1=pos2=UNDEF;
    113113                for(j=0;j<3;j++){
    114                         if (iomodel->Data(MeshElementsEnum)[3*(e1-1)+j]==i1) pos1=j+1;
    115                         if (iomodel->Data(MeshElementsEnum)[3*(e1-1)+j]==i2) pos2=j+1;
     114                        if (iomodel->elements[3*(e1-1)+j]==i1) pos1=j+1;
     115                        if (iomodel->elements[3*(e1-1)+j]==i2) pos2=j+1;
    116116                }
    117117                _assert_(pos1!=UNDEF && pos2!=UNDEF);

  • issm/trunk-jpl/src/c/classes/Loads/Pengrid.cpp

    r15104 r15428  
    4343        int pengrid_element_id;
    4444
    45         int numberofvertices;
    46         int numberofelements;
    47 
    48         /*Fetch parameters: */
    49         iomodel->Constant(&numberofvertices,MeshNumberofverticesEnum);
    50         iomodel->Constant(&numberofelements,MeshNumberofelementsEnum);
    51 
    5245        /*Some checks if debugging activated*/
    5346        _assert_(iomodel->singlenodetoelementconnectivity);
    54         _assert_(index>=0 && index<numberofvertices);
     47        _assert_(index>=0 && index<iomodel->numberofvertices);
    5548        _assert_(id);
    5649
    … …  
    6356        pengrid_element_id=iomodel->singlenodetoelementconnectivity[index];
    6457        _assert_(pengrid_element_id);
    65         pengrid_matpar_id=numberofelements+1; //refers to the constant material parameters object
     58        pengrid_matpar_id=iomodel->numberofelements+1; //refers to the constant material parameters object
    6659
    6760        this->hnode=new Hook(&pengrid_node_id,1);

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

    r15423 r15428  
    754754                /*Get B*/
    755755                if (iomodel->Data(MaterialsRheologyBEnum)) {
    756                         for(i=0;i<num_vertices;i++) nodeinputs[i]=iomodel->Data(MaterialsRheologyBEnum)[reCast<int,IssmDouble>(iomodel->Data(MeshElementsEnum)[num_vertices*index+i]-1)];
     756                        for(i=0;i<num_vertices;i++) nodeinputs[i]=iomodel->Data(MaterialsRheologyBEnum)[iomodel->elements[num_vertices*index+i]-1];
    757757                        this->inputs->AddInput(new TriaInput(MaterialsRheologyBbarEnum,nodeinputs,P1Enum));
    758758                }
    … …  
    766766                /*Get Z*/
    767767                if (iomodel->Data(MaterialsRheologyZEnum)) {
    768                         for(i=0;i<num_vertices;i++) nodeinputs[i]=iomodel->Data(MaterialsRheologyZEnum)[reCast<int,IssmDouble>(iomodel->Data(MeshElementsEnum)[num_vertices*index+i]-1)];
     768                        for(i=0;i<num_vertices;i++) nodeinputs[i]=iomodel->Data(MaterialsRheologyZEnum)[iomodel->elements[num_vertices*index+i]-1];
    769769                        this->inputs->AddInput(new TriaInput(MaterialsRheologyZbarEnum,nodeinputs,P1Enum));
    770770                }
    … …  
    778778                                                if (iomodel->Data(MaterialsRheologyBEnum)){
    779779                                                        _assert_(iomodel->Data(MaterialsRheologyBEnum));_assert_(iomodel->Data(InversionMinParametersEnum)); _assert_(iomodel->Data(InversionMaxParametersEnum));
    780                                                         for(j=0;j<num_vertices;j++)nodeinputs[j]=iomodel->Data(MaterialsRheologyBEnum)[reCast<int,IssmDouble>(iomodel->Data(MeshElementsEnum)[num_vertices*index+j]-1)];
    781                                                         for(j=0;j<num_vertices;j++)cmmininputs[j]=iomodel->Data(InversionMinParametersEnum)[reCast<int,IssmDouble>(iomodel->Data(MeshElementsEnum)[num_vertices*index+j]-1)*num_control_type+i];
    782                                                         for(j=0;j<num_vertices;j++)cmmaxinputs[j]=iomodel->Data(InversionMaxParametersEnum)[reCast<int,IssmDouble>(iomodel->Data(MeshElementsEnum)[num_vertices*index+j]-1)*num_control_type+i];
     780                                                        for(j=0;j<num_vertices;j++)nodeinputs[j]=iomodel->Data(MaterialsRheologyBEnum)[iomodel->elements[num_vertices*index+j]-1];
     781                                                        for(j=0;j<num_vertices;j++)cmmininputs[j]=iomodel->Data(InversionMinParametersEnum)[(iomodel->elements[num_vertices*index+j]-1)*num_control_type+i];
     782                                                        for(j=0;j<num_vertices;j++)cmmaxinputs[j]=iomodel->Data(InversionMaxParametersEnum)[(iomodel->elements[num_vertices*index+j]-1)*num_control_type+i];
    783783                                                        this->inputs->AddInput(new ControlInput(MaterialsRheologyBbarEnum,TriaInputEnum,nodeinputs,cmmininputs,cmmaxinputs,i+1));
    784784                                                }
    … …  
    787787                                                if (iomodel->Data(MaterialsRheologyZEnum)){
    788788                                                        _assert_(iomodel->Data(MaterialsRheologyZEnum));_assert_(iomodel->Data(InversionMinParametersEnum)); _assert_(iomodel->Data(InversionMaxParametersEnum));
    789                                                         for(j=0;j<num_vertices;j++)nodeinputs[j]=iomodel->Data(MaterialsRheologyZEnum)[reCast<int,IssmDouble>(iomodel->Data(MeshElementsEnum)[num_vertices*index+j]-1)];
    790                                                         for(j=0;j<num_vertices;j++)cmmininputs[j]=iomodel->Data(InversionMinParametersEnum)[reCast<int,IssmDouble>(iomodel->Data(MeshElementsEnum)[num_vertices*index+j]-1)*num_control_type+i];
    791                                                         for(j=0;j<num_vertices;j++)cmmaxinputs[j]=iomodel->Data(InversionMaxParametersEnum)[reCast<int,IssmDouble>(iomodel->Data(MeshElementsEnum)[num_vertices*index+j]-1)*num_control_type+i];
     789                                                        for(j=0;j<num_vertices;j++)nodeinputs[j]=iomodel->Data(MaterialsRheologyZEnum)[iomodel->elements[num_vertices*index+j]-1];
     790                                                        for(j=0;j<num_vertices;j++)cmmininputs[j]=iomodel->Data(InversionMinParametersEnum)[(iomodel->elements[num_vertices*index+j]-1)*num_control_type+i];
     791                                                        for(j=0;j<num_vertices;j++)cmmaxinputs[j]=iomodel->Data(InversionMaxParametersEnum)[(iomodel->elements[num_vertices*index+j]-1)*num_control_type+i];
    792792                                                        this->inputs->AddInput(new ControlInput(MaterialsRheologyZbarEnum,TriaInputEnum,nodeinputs,cmmininputs,cmmaxinputs,i+1));
    793793                                                }
    … …  
    812812                /*Get B*/
    813813                if (iomodel->Data(MaterialsRheologyBEnum)) {
    814                         for(i=0;i<num_vertices;i++) nodeinputs[i]=iomodel->Data(MaterialsRheologyBEnum)[reCast<int,IssmDouble>(iomodel->Data(MeshElementsEnum)[num_vertices*index+i]-1)];
     814                        for(i=0;i<num_vertices;i++) nodeinputs[i]=iomodel->Data(MaterialsRheologyBEnum)[iomodel->elements[num_vertices*index+i]-1];
    815815                        this->inputs->AddInput(new PentaInput(MaterialsRheologyBEnum,nodeinputs,P1Enum));
    816816                }
    … …  
    824824                /*Get Z*/
    825825                if (iomodel->Data(MaterialsRheologyZEnum)) {
    826                         for(i=0;i<num_vertices;i++) nodeinputs[i]=iomodel->Data(MaterialsRheologyZEnum)[reCast<int,IssmDouble>(iomodel->Data(MeshElementsEnum)[num_vertices*index+i]-1)];
     826                        for(i=0;i<num_vertices;i++) nodeinputs[i]=iomodel->Data(MaterialsRheologyZEnum)[iomodel->elements[num_vertices*index+i]-1];
    827827                        this->inputs->AddInput(new PentaInput(MaterialsRheologyZEnum,nodeinputs,P1Enum));
    828828                }
    … …  
    836836                                                if (iomodel->Data(MaterialsRheologyBEnum)){
    837837                                                        _assert_(iomodel->Data(MaterialsRheologyBEnum));_assert_(iomodel->Data(InversionMinParametersEnum)); _assert_(iomodel->Data(InversionMaxParametersEnum));
    838                                                         for(j=0;j<num_vertices;j++)nodeinputs[j]=iomodel->Data(MaterialsRheologyBEnum)[reCast<int,IssmDouble>(iomodel->Data(MeshElementsEnum)[num_vertices*index+j]-1)];
    839                                                         for(j=0;j<num_vertices;j++)cmmininputs[j]=iomodel->Data(InversionMinParametersEnum)[reCast<int,IssmDouble>(iomodel->Data(MeshElementsEnum)[num_vertices*index+j]-1)*num_control_type+i];
    840                                                         for(j=0;j<num_vertices;j++)cmmaxinputs[j]=iomodel->Data(InversionMaxParametersEnum)[reCast<int,IssmDouble>(iomodel->Data(MeshElementsEnum)[num_vertices*index+j]-1)*num_control_type+i];
     838                                                        for(j=0;j<num_vertices;j++)nodeinputs[j]=iomodel->Data(MaterialsRheologyBEnum)[iomodel->elements[num_vertices*index+j]-1];
     839                                                        for(j=0;j<num_vertices;j++)cmmininputs[j]=iomodel->Data(InversionMinParametersEnum)[(iomodel->elements[num_vertices*index+j]-1)*num_control_type+i];
     840                                                        for(j=0;j<num_vertices;j++)cmmaxinputs[j]=iomodel->Data(InversionMaxParametersEnum)[(iomodel->elements[num_vertices*index+j]-1)*num_control_type+i];
    841841                                                        this->inputs->AddInput(new ControlInput(MaterialsRheologyBEnum,PentaInputEnum,nodeinputs,cmmininputs,cmmaxinputs,i+1));
    842842                                                }
    … …  
    845845                                                if (iomodel->Data(MaterialsRheologyZEnum)){
    846846                                                        _assert_(iomodel->Data(MaterialsRheologyZEnum));_assert_(iomodel->Data(InversionMinParametersEnum)); _assert_(iomodel->Data(InversionMaxParametersEnum));
    847                                                         for(j=0;j<num_vertices;j++)nodeinputs[j]=iomodel->Data(MaterialsRheologyZEnum)[reCast<int,IssmDouble>(iomodel->Data(MeshElementsEnum)[num_vertices*index+j]-1)];
    848                                                         for(j=0;j<num_vertices;j++)cmmininputs[j]=iomodel->Data(InversionMinParametersEnum)[reCast<int,IssmDouble>(iomodel->Data(MeshElementsEnum)[num_vertices*index+j]-1)*num_control_type+i];
    849                                                         for(j=0;j<num_vertices;j++)cmmaxinputs[j]=iomodel->Data(InversionMaxParametersEnum)[reCast<int,IssmDouble>(iomodel->Data(MeshElementsEnum)[num_vertices*index+j]-1)*num_control_type+i];
     847                                                        for(j=0;j<num_vertices;j++)nodeinputs[j]=iomodel->Data(MaterialsRheologyZEnum)[iomodel->elements[num_vertices*index+j]-1];
     848                                                        for(j=0;j<num_vertices;j++)cmmininputs[j]=iomodel->Data(InversionMinParametersEnum)[(iomodel->elements[num_vertices*index+j]-1)*num_control_type+i];
     849                                                        for(j=0;j<num_vertices;j++)cmmaxinputs[j]=iomodel->Data(InversionMaxParametersEnum)[(iomodel->elements[num_vertices*index+j]-1)*num_control_type+i];
    850850                                                        this->inputs->AddInput(new ControlInput(MaterialsRheologyZEnum,PentaInputEnum,nodeinputs,cmmininputs,cmmaxinputs,i+1));
    851851                                                }

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

    r15423 r15428  
    704704                /*Get B*/
    705705                if (iomodel->Data(MaterialsRheologyBEnum)) {
    706                         for(i=0;i<num_vertices;i++) nodeinputs[i]=iomodel->Data(MaterialsRheologyBEnum)[reCast<int,IssmDouble>(iomodel->Data(MeshElementsEnum)[num_vertices*index+i]-1)];
     706                        for(i=0;i<num_vertices;i++) nodeinputs[i]=iomodel->Data(MaterialsRheologyBEnum)[iomodel->elements[num_vertices*index+i]-1];
    707707                        this->inputs->AddInput(new TriaInput(MaterialsRheologyBbarEnum,nodeinputs,P1Enum));
    708708                }
    … …  
    722722                                                if (iomodel->Data(MaterialsRheologyBEnum)){
    723723                                                        _assert_(iomodel->Data(MaterialsRheologyBEnum));_assert_(iomodel->Data(InversionMinParametersEnum)); _assert_(iomodel->Data(InversionMaxParametersEnum));
    724                                                         for(j=0;j<num_vertices;j++)nodeinputs[j]=iomodel->Data(MaterialsRheologyBEnum)[reCast<int,IssmDouble>(iomodel->Data(MeshElementsEnum)[num_vertices*index+j]-1)];
    725                                                         for(j=0;j<num_vertices;j++)cmmininputs[j]=iomodel->Data(InversionMinParametersEnum)[reCast<int,IssmDouble>(iomodel->Data(MeshElementsEnum)[num_vertices*index+j]-1)*num_control_type+i];
    726                                                         for(j=0;j<num_vertices;j++)cmmaxinputs[j]=iomodel->Data(InversionMaxParametersEnum)[reCast<int,IssmDouble>(iomodel->Data(MeshElementsEnum)[num_vertices*index+j]-1)*num_control_type+i];
     724                                                        for(j=0;j<num_vertices;j++)nodeinputs[j]=iomodel->Data(MaterialsRheologyBEnum)[iomodel->elements[num_vertices*index+j]-1];
     725                                                        for(j=0;j<num_vertices;j++)cmmininputs[j]=iomodel->Data(InversionMinParametersEnum)[(iomodel->elements[num_vertices*index+j]-1)*num_control_type+i];
     726                                                        for(j=0;j<num_vertices;j++)cmmaxinputs[j]=iomodel->Data(InversionMaxParametersEnum)[(iomodel->elements[num_vertices*index+j]-1)*num_control_type+i];
    727727                                                        this->inputs->AddInput(new ControlInput(MaterialsRheologyBbarEnum,TriaInputEnum,nodeinputs,cmmininputs,cmmaxinputs,i+1));
    728728                                                }
    … …  
    739739
    740740                /*Intermediaries*/
    741                 const int num_vertices = 6; //Penta has 6 vertices
    742                 IssmDouble    nodeinputs[num_vertices];
    743                 IssmDouble    cmmininputs[num_vertices];
    744                 IssmDouble    cmmaxinputs[num_vertices];
     741                const int  num_vertices = 6; //Penta has 6 vertices
     742                IssmDouble nodeinputs[num_vertices];
     743                IssmDouble cmmininputs[num_vertices];
     744                IssmDouble cmmaxinputs[num_vertices];
    745745
    746746                /*Get B*/
    747747                if (iomodel->Data(MaterialsRheologyBEnum)) {
    748                         for(i=0;i<num_vertices;i++) nodeinputs[i]=iomodel->Data(MaterialsRheologyBEnum)[reCast<int,IssmDouble>(iomodel->Data(MeshElementsEnum)[num_vertices*index+i]-1)];
     748                        for(i=0;i<num_vertices;i++) nodeinputs[i]=iomodel->Data(MaterialsRheologyBEnum)[iomodel->elements[num_vertices*index+i]-1];
    749749                        this->inputs->AddInput(new PentaInput(MaterialsRheologyBEnum,nodeinputs,P1Enum));
    750750                }
    … …  
    764764                                                if (iomodel->Data(MaterialsRheologyBEnum)){
    765765                                                        _assert_(iomodel->Data(MaterialsRheologyBEnum));_assert_(iomodel->Data(InversionMinParametersEnum)); _assert_(iomodel->Data(InversionMaxParametersEnum));
    766                                                         for(j=0;j<num_vertices;j++)nodeinputs[j]=iomodel->Data(MaterialsRheologyBEnum)[reCast<int,IssmDouble>(iomodel->Data(MeshElementsEnum)[num_vertices*index+j]-1)];
    767                                                         for(j=0;j<num_vertices;j++)cmmininputs[j]=iomodel->Data(InversionMinParametersEnum)[reCast<int,IssmDouble>(iomodel->Data(MeshElementsEnum)[num_vertices*index+j]-1)*num_control_type+i];
    768                                                         for(j=0;j<num_vertices;j++)cmmaxinputs[j]=iomodel->Data(InversionMaxParametersEnum)[reCast<int,IssmDouble>(iomodel->Data(MeshElementsEnum)[num_vertices*index+j]-1)*num_control_type+i];
     766                                                        for(j=0;j<num_vertices;j++)nodeinputs[j]=iomodel->Data(MaterialsRheologyBEnum)[iomodel->elements[num_vertices*index+j]-1];
     767                                                        for(j=0;j<num_vertices;j++)cmmininputs[j]=iomodel->Data(InversionMinParametersEnum)[(iomodel->elements[num_vertices*index+j]-1)*num_control_type+i];
     768                                                        for(j=0;j<num_vertices;j++)cmmaxinputs[j]=iomodel->Data(InversionMaxParametersEnum)[(iomodel->elements[num_vertices*index+j]-1)*num_control_type+i];
    769769                                                        this->inputs->AddInput(new ControlInput(MaterialsRheologyBEnum,PentaInputEnum,nodeinputs,cmmininputs,cmmaxinputs,i+1));
    770770                                                }

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

    r15186 r15428  
    2020        bool        spcpresent       = false;
    2121        int         count            = 0;
    22         int         numberofvertices;
    2322
    2423        /*variables being fetched: */
    … …  
    2726
    2827        /*Fetch parameters: */
    29         iomodel->Constant(&numberofvertices,MeshNumberofverticesEnum);
    3028        iomodel->Constant(&yts,ConstantsYtsEnum);
    3129
    … …  
    4038
    4139        /*Transient or static?:*/
    42         if(M==numberofvertices){
     40        if(M==iomodel->numberofvertices){
    4341                /*static: just create Constraints objects*/
    4442                count=0;
    4543
    4644                /*Create Constraints from x,y,z: */
    47                 for (i=0;i<numberofvertices;i++){
     45                for (i=0;i<iomodel->numberofvertices;i++){
    4846
    4947                        /*keep only this partition's nodes:*/
    … …  
    5856                }
    5957        }
    60         else if (M==(numberofvertices+1)){
     58        else if (M==(iomodel->numberofvertices+1)){
    6159                /*transient: create transient SpcTransient objects. Same logic, except we need to retrieve
    6260                 * various times and values to initialize an SpcTransient object: */
    … …  
    7068
    7169                /*Create constraints from x,y,z: */
    72                 for (i=0;i<numberofvertices;i++){
     70                for (i=0;i<iomodel->numberofvertices;i++){
    7371
    7472                        /*keep only this partition's nodes:*/

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

    r14999 r15428  
    1010/* local prototypes: */
    1111template <class doubletype>
    12 int MeshPartitionx(int** pepart, int** pnpart, int numberofelements,int numberofnodes,doubletype* elements,
     12int MeshPartitionx(int** pepart, int** pnpart, int numberofelements,int numberofnodes,int* elements,
    1313                int numberofelements2d,int numberofnodes2d,doubletype* elements2d,int numlayers,int elements_width, int dim,int num_procs){
    1414
    … …  
    3737                for (i=0;i<numberofelements;i++){
    3838                        for (j=0;j<elements_width;j++){
    39                                 *(index+elements_width*i+j)=reCast<int>(*(elements+elements_width*i+j))-1; //-1 for C indexing in Metis
     39                                *(index+elements_width*i+j)=(*(elements+elements_width*i+j))-1; //-1 for C indexing in Metis
    4040                        }
    4141                }
    … …  
    118118        xDelete<int>(index2d);
    119119        return noerr;
    120 }       
     120}
    121121#endif /* _MESHPARTITIONX_H */

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

    r15000 r15428  
    2828
    2929                /*Get edges and elements*/
    30                 iomodel->FetchData(3,MeshEdgesEnum,MeshElementsEnum,ThicknessEnum);
     30                iomodel->FetchData(2,MeshEdgesEnum,ThicknessEnum);
    3131
    3232                /*First load data:*/
    … …  
    4444
    4545                /*Free data: */
    46                 iomodel->DeleteData(3,MeshEdgesEnum,MeshElementsEnum,ThicknessEnum);
     46                iomodel->DeleteData(2,MeshEdgesEnum,ThicknessEnum);
    4747        }
    4848

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

    r15423 r15428  
    1717        int  io_index;
    1818        bool continuous_galerkin=true;
    19         int    numberofelements;
    20         int    numberofvertices;
    21         int    stabilization;
     19        int  stabilization;
    2220
    2321        /*Fetch parameters: */
    24         iomodel->Constant(&numberofelements,MeshNumberofelementsEnum);
    25         iomodel->Constant(&numberofvertices,MeshNumberofverticesEnum);
    2622        iomodel->Constant(&stabilization,BalancethicknessStabilizationEnum);
    2723
    … …  
    4036
    4137        /*First fetch data: */
    42         iomodel->FetchData(7,MeshElementsEnum,MeshVertexonbedEnum,MeshVertexonsurfaceEnum,MaskVertexongroundediceEnum,MaskVertexonfloatingiceEnum,FlowequationVertexEquationEnum,MaskVertexonwaterEnum);
     38        iomodel->FetchData(6,MeshVertexonbedEnum,MeshVertexonsurfaceEnum,MaskVertexongroundediceEnum,MaskVertexonfloatingiceEnum,FlowequationVertexEquationEnum,MaskVertexonwaterEnum);
    4339
    4440        if(continuous_galerkin){
    4541
    4642                /*Build Nodes dataset (Continuous Galerkin)*/
    47                 for (i=0;i<numberofvertices;i++){
     43                for (i=0;i<iomodel->numberofvertices;i++){
    4844                        if(iomodel->my_vertices[i]){
    4945
    … …  
    5753
    5854                /*Build Nodes dataset -> 3 for each element (Discontinuous Galerkin)*/
    59                 for (i=0;i<numberofelements;i++){
     55                for (i=0;i<iomodel->numberofelements;i++){
    6056                        for (j=0;j<3;j++){
    6157
    … …  
    6359
    6460                                        //Get index of the vertex on which the current node is located
    65                                         vertex_id=reCast<int,IssmDouble>(*(iomodel->Data(MeshElementsEnum)+3*i+j)); //(Matlab indexing)
    66                                         io_index=vertex_id-1;                      //(C indexing)
    67                                         _assert_(vertex_id>0 && vertex_id<=numberofvertices);
     61                                        vertex_id=iomodel->elements[3*i+j]; //(Matlab indexing)
     62                                        io_index=vertex_id-1;               //(C indexing)
     63                                        _assert_(vertex_id>0 && vertex_id<=iomodel->numberofvertices);
    6864
    6965                                        //Compute Node id
    … …  
    7975
    8076        /*Clean fetched data: */
    81         iomodel->DeleteData(7,MeshElementsEnum,MeshVertexonbedEnum,MeshVertexonsurfaceEnum,MaskVertexongroundediceEnum,MaskVertexonfloatingiceEnum,FlowequationVertexEquationEnum,MaskVertexonwaterEnum);
     77        iomodel->DeleteData(6,MeshVertexonbedEnum,MeshVertexonsurfaceEnum,MaskVertexongroundediceEnum,MaskVertexonfloatingiceEnum,FlowequationVertexEquationEnum,MaskVertexonwaterEnum);
    8278
    8379        /*Assign output pointer: */

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

    r15423 r15428  
    1111void    UpdateElementsBalancethickness(Elements* elements, IoModel* iomodel,int analysis_counter,int analysis_type){
    1212
    13         int    numberofelements;
    14 
    15         /*Fetch data needed: */
    16         iomodel->Constant(&numberofelements,MeshNumberofelementsEnum);
    17         iomodel->FetchData(1,MeshElementsEnum);
    18 
    1913        /*Update elements: */
    2014        int counter=0;
    21         for(int i=0;i<numberofelements;i++){
     15        for(int i=0;i<iomodel->numberofelements;i++){
    2216                if(iomodel->my_elements[i]){
    2317                        Element* element=(Element*)elements->GetObjectByOffset(counter);
    … …  
    4236                iomodel->FetchDataToInput(elements,MeshElementonsurfaceEnum);
    4337        }
    44         /*Free data: */
    45         iomodel->DeleteData(1,MeshElementsEnum);
    4638}

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

    r15000 r15428  
    1212
    1313        /*Intermediary*/
    14         int i;
    1514        bool continuous_galerkin=true;
    16 
    17         /*Fetch parameters: */
    18         int    numberofvertices;
    19         iomodel->Constant(&numberofvertices,MeshNumberofverticesEnum);
    2015
    2116        /*Recover pointer: */
    … …  
    3126        iomodel->FetchData(6,MeshVertexonbedEnum,MeshVertexonsurfaceEnum,MaskVertexongroundediceEnum,MaskVertexonfloatingiceEnum,FlowequationVertexEquationEnum,MaskVertexonwaterEnum);
    3227
    33         for (i=0;i<numberofvertices;i++){
     28        for(int i=0;i<iomodel->numberofvertices;i++){
    3429                if(iomodel->my_vertices[i]){
    3530

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

    r15423 r15428  
    1111void    UpdateElementsBedSlope(Elements* elements, IoModel* iomodel,int analysis_counter,int analysis_type){
    1212
    13         int    numberofelements;
    14 
    15         /*Fetch data needed: */
    16         iomodel->Constant(&numberofelements,MeshNumberofelementsEnum);
    17         iomodel->FetchData(1,MeshElementsEnum);
    18 
    1913        /*Update elements: */
    2014        int counter=0;
    21         for(int i=0;i<numberofelements;i++){
     15        for(int i=0;i<iomodel->numberofelements;i++){
    2216                if(iomodel->my_elements[i]){
    2317                        Element* element=(Element*)elements->GetObjectByOffset(counter);
    … …  
    3024        iomodel->FetchDataToInput(elements,BedEnum);
    3125        iomodel->FetchDataToInput(elements,MaskElementonwaterEnum);
    32 
    3326        if(iomodel->dim==3){
    3427                iomodel->FetchDataToInput(elements,MeshElementonbedEnum);
    3528                iomodel->FetchDataToInput(elements,MeshElementonsurfaceEnum);
    3629        }
    37 
    38         /*Free data: */
    39         iomodel->DeleteData(1,MeshElementsEnum);
    4030}

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

    r15000 r15428  
    2929
    3030        /*Fetch data needed: */
    31         iomodel->FetchData(1,MeshElementsEnum);
    3231        iomodel->FetchDataToInput(elements,InversionVxObsEnum);
    3332        iomodel->FetchDataToInput(elements,InversionVyObsEnum);
    … …  
    6261
    6362        /*Free data: */
    64         iomodel->DeleteData(1+4+6,MeshElementsEnum,InversionControlParametersEnum,InversionCostFunctionsCoefficientsEnum,InversionMinParametersEnum,InversionMaxParametersEnum,BalancethicknessThickeningRateEnum,VxEnum,VyEnum,FrictionCoefficientEnum,MaterialsRheologyBEnum,MaterialsRheologyZEnum);
     63        iomodel->DeleteData(4+6,InversionControlParametersEnum,InversionCostFunctionsCoefficientsEnum,InversionMinParametersEnum,InversionMaxParametersEnum,BalancethicknessThickeningRateEnum,VxEnum,VyEnum,FrictionCoefficientEnum,MaterialsRheologyBEnum,MaterialsRheologyZEnum);
    6564}

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

    r15423 r15428  
    1313        int i;
    1414        int materials_type;
    15         int numberofelements;
    16         int numberofvertices;
    1715        bool control_analysis;
    1816        bool dakota_analysis;
    … …  
    2422
    2523        /*Fetch parameters: */
    26         iomodel->Constant(&numberofelements,MeshNumberofelementsEnum);
    27         iomodel->Constant(&numberofvertices,MeshNumberofverticesEnum);
    2824        iomodel->Constant(&control_analysis,InversionIscontrolEnum);
    2925        iomodel->Constant(&dakota_analysis,QmuIsdakotaEnum);
    … …  
    3834        materials = new Materials();
    3935
    40         iomodel->FetchData(2,MeshElementsEnum,MeshElementconnectivityEnum);
     36        iomodel->FetchData(1,MeshElementconnectivityEnum);
    4137        #ifdef _HAVE_3D_
    4238        if(iomodel->dim==3)iomodel->FetchData(2,MeshUpperelementsEnum,MeshLowerelementsEnum);
    … …  
    4541
    4642        /*Create elements*/
    47         for (i=0;i<numberofelements;i++){
     43        for(i=0;i<iomodel->numberofelements;i++){
    4844                if(iomodel->my_elements[i]){
    4945
    … …  
    6056                case MaticeEnum:
    6157                        iomodel->FetchData(2,MaterialsRheologyBEnum,MaterialsRheologyNEnum);
    62                         for (i=0;i<numberofelements;i++) if(iomodel->my_elements[i]) materials->AddObject(new Matice(i+1,i,iomodel));
     58                        for (i=0;i<iomodel->numberofelements;i++) if(iomodel->my_elements[i]) materials->AddObject(new Matice(i+1,i,iomodel));
    6359                        if(dakota_analysis){
    6460                                if(iomodel->dim==2) materials->InputDuplicate(MaterialsRheologyBbarEnum,QmuMaterialsRheologyBEnum);
    … …  
    7066                case MatdamageiceEnum:
    7167                        iomodel->FetchData(3,MaterialsRheologyBEnum,MaterialsRheologyNEnum,MaterialsRheologyZEnum);
    72                         for (i=0;i<numberofelements;i++) if(iomodel->my_elements[i]) materials->AddObject(new Matdamageice(i+1,i,iomodel));
     68                        for (i=0;i<iomodel->numberofelements;i++) if(iomodel->my_elements[i]) materials->AddObject(new Matdamageice(i+1,i,iomodel));
    7369                        break;
    7470                default:
    … …  
    7773
    7874        /*Free data: */
    79         iomodel->DeleteData(10,MeshElementsEnum,MeshElementconnectivityEnum,MeshUpperelementsEnum,MeshLowerelementsEnum,
     75        iomodel->DeleteData(9,MeshElementconnectivityEnum,MeshUpperelementsEnum,MeshLowerelementsEnum,
    8076                                MaterialsRheologyBEnum,MaterialsRheologyNEnum,MaterialsRheologyZEnum,InversionControlParametersEnum,InversionMinParametersEnum,
    8177                                InversionMaxParametersEnum);
    8278
    8379        /*Add new constant material property to materials, at the end: */
    84         materials->AddObject(new Matpar(numberofelements+1,iomodel));//put it at the end of the materials
     80        materials->AddObject(new Matpar(iomodel->numberofelements+1,iomodel));//put it at the end of the materials
    8581
    8682        /*Create vertices: */
    8783
    8884        /*Fetch data:*/
    89         iomodel->FetchData(7,MeshElementsEnum,MeshXEnum,MeshYEnum,MeshZEnum,BedEnum,ThicknessEnum,IcelevelsetEnum);
     85        iomodel->FetchData(6,MeshXEnum,MeshYEnum,MeshZEnum,BedEnum,ThicknessEnum,IcelevelsetEnum);
    9086        CreateNumberNodeToElementConnectivity(iomodel);
    9187
    92         for (i=0;i<numberofvertices;i++){
     88        for(i=0;i<iomodel->numberofvertices;i++){
    9389
    9490                /*vertices and nodes (same number, as we are running continuous galerkin formulation): */
    … …  
    10197
    10298        /*Free data: */
    103         iomodel->DeleteData(7,MeshElementsEnum,MeshXEnum,MeshYEnum,MeshZEnum,BedEnum,ThicknessEnum,IcelevelsetEnum);
     99        iomodel->DeleteData(6,MeshXEnum,MeshYEnum,MeshZEnum,BedEnum,ThicknessEnum,IcelevelsetEnum);
    104100
    105101        /*Assign output pointer: */

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

    r15423 r15428  
    2020        int vertexid;
    2121        int elementswidth;
    22         int numberofelements;
    23         int numberofvertices;
    24         IssmDouble* elements=NULL;
    2522
    2623        /*output*/
    … …  
    3027        if(iomodel->numbernodetoelementconnectivity) return;
    3128
    32         /*Fetch parameters: */
    33         iomodel->Constant(&numberofelements,MeshNumberofelementsEnum);
    34         iomodel->Constant(&numberofvertices,MeshNumberofverticesEnum);
    35         elements=iomodel->Data(MeshElementsEnum);
    36 
    3729        /*Some checks if debugging*/
    38         _assert_(numberofvertices);
    39         _assert_(numberofelements);
    40         _assert_(elements);
     30        _assert_(iomodel->numberofvertices);
     31        _assert_(iomodel->numberofelements);
     32        _assert_(iomodel->elements);
    4133
    4234        /*Allocate ouput*/
    43         connectivity=xNewZeroInit<int>(numberofvertices);
     35        connectivity=xNewZeroInit<int>(iomodel->numberofvertices);
    4436
    4537        /*Get element width (3 or 6)*/
    46         if (iomodel->dim==2){
     38        if(iomodel->dim==2){
    4739                elementswidth=3;
    4840        }
    … …  
    5244
    5345        /*Create connectivity table*/
    54         for (i=0;i<numberofelements;i++){
     46        for (i=0;i<iomodel->numberofelements;i++){
    5547                for (j=0;j<elementswidth;j++){
    56                         vertexid=reCast<int>(elements[elementswidth*i+j]);
    57                         _assert_(vertexid>0 && vertexid-1<numberofvertices);
     48                        vertexid=iomodel->elements[elementswidth*i+j];
     49                        _assert_(vertexid>0 && vertexid-1<iomodel->numberofvertices);
    5850                        connectivity[vertexid-1]+=1;
    5951                }
    … …  
    6254        /*Assign to iomodel*/
    6355        iomodel->numbernodetoelementconnectivity=connectivity;
    64 
    65         /*Do not free connectivity!!!*/
    6656}

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

    r15423 r15428  
    1717
    1818        /*Intermediary*/
    19         int i,j;
    2019        int vertexid;
    2120        int elementswidth;
    22         int    numberofelements;
    23         int    numberofvertices;
    24         IssmDouble* elements=NULL;
    2521
    2622        /*output*/
    … …  
    3026        if(iomodel->singlenodetoelementconnectivity) return;
    3127
    32         /*Fetch parameters: */
    33         iomodel->Constant(&numberofelements,MeshNumberofelementsEnum);
    34         iomodel->Constant(&numberofvertices,MeshNumberofverticesEnum);
    35         elements=iomodel->Data(MeshElementsEnum);
    36 
    3728        /*Some checks if debugging*/
    38         _assert_(numberofvertices);
    39         _assert_(numberofelements);
     29        _assert_(iomodel->numberofvertices);
     30        _assert_(iomodel->numberofelements);
    4031        _assert_(iomodel->my_elements);
    41         _assert_(elements);
     32        _assert_(iomodel->elements);
    4233
    4334        /*Allocate ouput*/
    44         connectivity=xNewZeroInit<int>(numberofvertices);
     35        connectivity=xNewZeroInit<int>(iomodel->numberofvertices);
    4536
    4637        /*Get element width (3 or 6)*/
    … …  
    5344
    5445        /*Create connectivity table*/
    55         for (i=0;i<numberofelements;i++){
     46        for(int i=0;i<iomodel->numberofelements;i++){
    5647                /*!! in parallel we do not want the vertex to be connected to an element that is not in its partition!!*/
    5748                if(iomodel->my_elements[i]){
    58                         for (j=0;j<elementswidth;j++){
    59                                 vertexid=reCast<int>(elements[elementswidth*i+j]);
    60                                 _assert_(vertexid>0 && vertexid-1<numberofvertices);
     49                        for(int j=0;j<elementswidth;j++){
     50                                vertexid=iomodel->elements[elementswidth*i+j];
     51                                _assert_(vertexid>0 && vertexid-1<iomodel->numberofvertices);
    6152                                connectivity[vertexid-1]=i+1;
    6253                        }
    … …  
    6657        /*Assign to iomodel*/
    6758        iomodel->singlenodetoelementconnectivity=connectivity;
    68 
    69         /*Do not free connectivity!!!*/
    7059}

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

    r15000 r15428  
    3636        char*    name=NULL;
    3737        int      numberofresponses;
    38         int      numberofvertices;
    3938        int      nrows;
    4039        int      ncols;
    … …  
    5251                iomodel->Constant(&name,MiscellaneousNameEnum);
    5352                iomodel->Constant(&numberofresponses,QmuNumberofresponsesEnum);
    54                 iomodel->Constant(&numberofvertices,MeshNumberofverticesEnum);
    5553
    5654                /*name of qmu input, error and output files:{{{*/
    … …  
    9290                        ElementsAndVerticesPartitioning(&iomodel->my_elements,&iomodel->my_vertices,iomodel);
    9391
    94                         dpart=xNew<double>(numberofvertices);
    95                         for(i=0;i<numberofvertices;i++)dpart[i]=iomodel->my_vertices[i];
     92                        dpart=xNew<double>(iomodel->numberofvertices);
     93                        for(i=0;i<iomodel->numberofvertices;i++)dpart[i]=iomodel->my_vertices[i];
    9694                }
    97                 parameters->AddObject(new DoubleVecParam(QmuPartitionEnum,dpart,numberofvertices));
     95                parameters->AddObject(new DoubleVecParam(QmuPartitionEnum,dpart,iomodel->numberofvertices));
    9896                /*}}}*/
    9997                /*Deal with data needed because of qmu variables: {{{*/
    … …  
    109107
    110108                                /*Add to parameters: */
    111                                 if(nrows==numberofvertices){
     109                                if(nrows==iomodel->numberofvertices){
    112110                                        parameters->AddObject(new DoubleMatParam(StringToEnumx(tag),dakota_parameter,nrows,ncols));
    113111                                }

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

    r15423 r15428  
    4141        Constraints *constraints      = NULL;
    4242        SpcStatic   *spcstatic        = NULL;
    43         int          numberofvertices;
    4443
    4544        /*Fetch parameters: */
    4645        iomodel->Constant(&yts,ConstantsYtsEnum);
    47         iomodel->Constant(&numberofvertices,MeshNumberofverticesEnum);
    4846        iomodel->Constant(&g,ConstantsGEnum);
    4947        iomodel->Constant(&rho_ice,MaterialsRhoIceEnum);
    … …  
    9896
    9997        /*Create spcs from x,y,z, as well as the spc values on those spcs: */
    100         for (i=0;i<numberofvertices;i++){
     98        for(i=0;i<iomodel->numberofvertices;i++){
    10199                if(iomodel->my_vertices[i]){
    102100
    … …  
    218216                        /*Now add the regular spcs*/
    219217                        else{
    220                                 if (Mx==numberofvertices && !xIsNan<IssmDouble>(spcvx[i])){
     218                                if (Mx==iomodel->numberofvertices && !xIsNan<IssmDouble>(spcvx[i])){
    221219                                        constraints->AddObject(new SpcStatic(iomodel->constraintcounter+count+1,iomodel->nodecounter+i+1,1,spcvx[i]/yts,DiagnosticHorizAnalysisEnum)); //add count'th spc, on node i+1, setting dof 1 to vx.
    222220                                        count++;
    223221                                }
    224                                 else if (Mx==numberofvertices+1) {
     222                                else if (Mx==iomodel->numberofvertices+1) {
    225223                                        /*figure out times and values: */
    226224                                        values=xNew<IssmDouble>(Nx);
    … …  
    242240                                }
    243241
    244                                 if (My==numberofvertices && !xIsNan<IssmDouble>(spcvy[i])){
     242                                if (My==iomodel->numberofvertices && !xIsNan<IssmDouble>(spcvy[i])){
    245243                                        constraints->AddObject(new SpcStatic(iomodel->constraintcounter+count+1,iomodel->nodecounter+i+1,2,spcvy[i]/yts,DiagnosticHorizAnalysisEnum)); //add count'th spc, on node i+1, setting dof 1 to vy.
    246244                                        count++;
    247245                                }
    248                                 else if (My==numberofvertices+1){
     246                                else if (My==iomodel->numberofvertices+1){
    249247                                        /*figure out times and values: */
    250248                                        values=xNew<IssmDouble>(Ny);
    … …  
    266264
    267265                                if (reCast<int,IssmDouble>(vertices_type[i])==StokesApproximationEnum ||  (reCast<int,IssmDouble>(vertices_type[i])==NoneApproximationEnum)){
    268                                         if (Mz==numberofvertices && !xIsNan<IssmDouble>(spcvz[i])){
     266                                        if (Mz==iomodel->numberofvertices && !xIsNan<IssmDouble>(spcvz[i])){
    269267                                                constraints->AddObject(new SpcStatic(iomodel->constraintcounter+count+1,iomodel->nodecounter+i+1,3,spcvz[i]/yts,DiagnosticHorizAnalysisEnum)); //add count'th spc, on node i+1, setting dof 2 to vy
    270268                                                count++;
    271269                                        }
    272                                         else if (Mz==numberofvertices+1){
     270                                        else if (Mz==iomodel->numberofvertices+1){
    273271                                                /*figure out times and values: */
    274272                                                values=xNew<IssmDouble>(Nz);

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

    r15423 r15428  
    1919        int count=0;
    2020        int penpair_ids[2];
    21         int numberofvertices;
    2221        bool ismacayealpattyn,isstokes,isl1l2;
    2322        int  numpenalties,numberofpressureloads,numrifts,numriftsegments;
    … …  
    3332
    3433        /*Fetch parameters: */
    35         iomodel->Constant(&numberofvertices,MeshNumberofverticesEnum);
    3634        iomodel->Constant(&isl1l2,FlowequationIsl1l2Enum);
    3735        iomodel->Constant(&isstokes,FlowequationIsstokesEnum);

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

    r15298 r15428  
    1212
    1313        /*Intermediary*/
    14         int i;
    1514        bool   continuous_galerkin=true;
    16         int    numberofvertices;
    1715        bool   isstokes,isl1l2,ismacayealpattyn;
    1816
    1917        /*Fetch parameters: */
    20         iomodel->Constant(&numberofvertices,MeshNumberofverticesEnum);
    2118        iomodel->Constant(&isstokes,FlowequationIsstokesEnum);
    2219        iomodel->Constant(&isl1l2,FlowequationIsl1l2Enum);
    … …  
    4239                                MaskVertexongroundediceEnum,MaskVertexonfloatingiceEnum,MaskVertexonwaterEnum,FlowequationVertexEquationEnum,DiagnosticReferentialEnum);
    4340
    44         for (i=0;i<numberofvertices;i++){
     41        for(int i=0;i<iomodel->numberofvertices;i++){
    4542
    4643                if(iomodel->my_vertices[i]){
    … …  
    5956                iomodel->Constant(&numberofedges,MeshNumberofedgesEnum);
    6057
    61                 for (i=0;i<numberofedges;i++){
     58                for(int i=0;i<numberofedges;i++){
    6259
    6360                        /*Get left and right elements*/
    … …  
    7370                        /*Add node on edge*/
    7471                        if(my_edge){
    75                                 nodes->AddObject(new Node(iomodel->nodecounter+numberofvertices+i+1,numberofvertices+i,numberofvertices+i+1,i,iomodel,DiagnosticHorizAnalysisEnum));
     72                                nodes->AddObject(new Node(iomodel->nodecounter+iomodel->numberofvertices+i+1,iomodel->numberofvertices+i,iomodel->numberofvertices+i+1,i,iomodel,DiagnosticHorizAnalysisEnum));
    7673                        }
    7774                }

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

    r15423 r15428  
    1717
    1818        int    materials_type;
    19         int    numberofelements;
    2019        bool   ismacayealpattyn;
    2120        bool   isl1l2;
    … …  
    2827        iomodel->Constant(&isl1l2,FlowequationIsl1l2Enum);
    2928        iomodel->Constant(&ismacayealpattyn,FlowequationIsmacayealpattynEnum);
    30         iomodel->Constant(&numberofelements,MeshNumberofelementsEnum);
    3129        iomodel->Constant(&control_analysis,InversionIscontrolEnum);
    3230        iomodel->Constant(&dakota_analysis,QmuIsdakotaEnum);
    … …  
    3735
    3836        /*Fetch data needed: */
    39         iomodel->FetchData(2,MeshElementsEnum,FlowequationElementEquationEnum);
     37        iomodel->FetchData(1,FlowequationElementEquationEnum);
    4038
    4139        /*Update elements: */
    4240        int counter=0;
    43         for(int i=0;i<numberofelements;i++){
     41        for(int i=0;i<iomodel->numberofelements;i++){
    4442                if(iomodel->my_elements[i]){
    4543                        Element* element=(Element*)elements->GetObjectByOffset(counter);
    … …  
    103101
    104102        /*Free data: */
    105         iomodel->DeleteData(2,MeshElementsEnum,FlowequationElementEquationEnum);
     103        iomodel->DeleteData(1,FlowequationElementEquationEnum);
    106104}

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

    r15000 r15428  
    1111
    1212        /*Intermediary*/
    13         int i;
    14         int count;
     13        int        count;
    1514        IssmDouble yts;
    16         int    numberofvertices;
    17         bool   ishutter;
     15        bool       ishutter;
    1816
    1917        /*Output*/
    … …  
    2624        /*Fetch parameters: */
    2725        iomodel->Constant(&yts,ConstantsYtsEnum);
    28         iomodel->Constant(&numberofvertices,MeshNumberofverticesEnum);
    2926        iomodel->Constant(&ishutter,FlowequationIshutterEnum);
    3027
    … …  
    4542
    4643        /*vx and vy are spc'd if we are not on nodeonhutter: */
    47         for (i=0;i<numberofvertices;i++){
     44        for(int i=0;i<iomodel->numberofvertices;i++){
    4845                /*keep only this partition's nodes:*/
    4946                if((iomodel->my_vertices[i])){

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

    r15000 r15428  
    1212
    1313        /*Intermediary*/
    14         int i;
    15         bool continuous_galerkin=true;
    16         int    numberofvertices;
    17         bool   ishutter;
     14        bool continuous_galerkin = true;
     15        bool ishutter;
    1816
    1917        /*Fetch parameters: */
    20         iomodel->Constant(&numberofvertices,MeshNumberofverticesEnum);
    2118        iomodel->Constant(&ishutter,FlowequationIshutterEnum);
    2219
    … …  
    3734
    3835        /*First fetch data: */
    39         iomodel->FetchData(7,MeshVertexonbedEnum,MeshVertexonsurfaceEnum,MaskVertexongroundediceEnum,MaskVertexonfloatingiceEnum,MeshElementsEnum,FlowequationVertexEquationEnum,MaskVertexonwaterEnum);
     36        iomodel->FetchData(6,MeshVertexonbedEnum,MeshVertexonsurfaceEnum,MaskVertexongroundediceEnum,MaskVertexonfloatingiceEnum,FlowequationVertexEquationEnum,MaskVertexonwaterEnum);
    4037
    41         for (i=0;i<numberofvertices;i++){
     38        for(int i=0;i<iomodel->numberofvertices;i++){
    4239                if(iomodel->my_vertices[i]){
    4340
    … …  
    4946
    5047        /*Clean fetched data: */
    51         iomodel->DeleteData(7,MeshVertexonbedEnum,MeshVertexonsurfaceEnum,MaskVertexongroundediceEnum,MaskVertexonfloatingiceEnum,MeshElementsEnum,FlowequationVertexEquationEnum,MaskVertexonwaterEnum);
     48        iomodel->DeleteData(6,MeshVertexonbedEnum,MeshVertexonsurfaceEnum,MaskVertexongroundediceEnum,MaskVertexonfloatingiceEnum,FlowequationVertexEquationEnum,MaskVertexonwaterEnum);
    5249
    5350        /*Assign output pointer: */

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

    r15000 r15428  
    2121        if (!ishutter)return;
    2222
    23         iomodel->FetchData(2,MeshElementsEnum,FlowequationElementEquationEnum);
     23        iomodel->FetchData(1,FlowequationElementEquationEnum);
    2424
    2525        /*Update elements: */
    … …  
    3737
    3838        /*Free data: */
    39         iomodel->DeleteData(2,MeshElementsEnum,FlowequationElementEquationEnum);
     39        iomodel->DeleteData(1,FlowequationElementEquationEnum);
    4040}

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

    r15423 r15428  
    1111
    1212        /*Intermediary*/
    13         int i;
    1413        int count;
    1514        IssmDouble yts;
    16         int    numberofvertices;
    1715
    1816        /*Fetch parameters: */
    1917        iomodel->Constant(&yts,ConstantsYtsEnum);
    20         iomodel->Constant(&numberofvertices,MeshNumberofverticesEnum);
    2118
    2219        /*Recover pointer: */
    … …  
    3936
    4037        /*Create spcs from x,y,z, as well as the spc values on those spcs: */
    41         for (i=0;i<numberofvertices;i++){
     38        for(int i=0;i<iomodel->numberofvertices;i++){
    4239
    4340                /*keep only this partition's nodes:*/

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

    r15423 r15428  
    1212
    1313        /*Intermediary*/
    14         int i;
    1514        bool continuous_galerkin=true;
    16         int    numberofvertices;
    17 
    18         /*Fetch parameters: */
    19         iomodel->Constant(&numberofvertices,MeshNumberofverticesEnum);
    2015
    2116        /*Recover pointer: */
    … …  
    3732        iomodel->FetchData(6,MeshVertexonbedEnum,MeshVertexonsurfaceEnum,MaskVertexongroundediceEnum,MaskVertexonfloatingiceEnum,FlowequationVertexEquationEnum,MaskVertexonwaterEnum);
    3833
    39         for (i=0;i<numberofvertices;i++){
     34        for(int i=0;i<iomodel->numberofvertices;i++){
    4035                if(iomodel->my_vertices[i]){
    4136

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

    r15423 r15428  
    1414        if (iomodel->dim==2)return;
    1515
    16         int    numberofelements;
    17 
    18         /*Fetch parameters: */
    19         iomodel->Constant(&numberofelements,MeshNumberofelementsEnum);
    20 
    21         /*Fetch data needed: */
    22         iomodel->FetchData(1,MeshElementsEnum);
    23 
    2416        /*Update elements: */
    2517        int counter=0;
    26         for(int i=0;i<numberofelements;i++){
     18        for(int i=0;i<iomodel->numberofelements;i++){
    2719                if(iomodel->my_elements[i]){
    2820                        Element* element=(Element*)elements->GetObjectByOffset(counter);
    … …  
    4436        iomodel->FetchDataToInput(elements,VxEnum);
    4537        iomodel->FetchDataToInput(elements,VyEnum);
    46 
    47         /*Free data: */
    48         iomodel->DeleteData(1,MeshElementsEnum);
    49 
    5038}

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

    r15423 r15428  
    2121        int my_rank;
    2222        int num_procs;
    23         int    numberofelements;
    24         int    numberofvertices;
    2523        int    numberofelements2d;
    2624        int    numberofvertices2d;
    … …  
    3836        int  elements_width; //number of columns in elements (2d->3, 3d->6)
    3937        int  el1,el2;
    40         IssmDouble* elements=NULL;
    41         IssmDouble* elements2d=NULL;
     38        int* elements2d=NULL;
     39        int* vertex_pairing=NULL;
    4240        IssmDouble* riftinfo=NULL;
    43         IssmDouble* vertex_pairing=NULL;
    4441
    4542        /*Get my_rank:*/
    46         my_rank=IssmComm::GetRank();
    47         num_procs=IssmComm::GetSize();
     43        my_rank   = IssmComm::GetRank();
     44        num_procs = IssmComm::GetSize();
    4845
    4946        /*Fetch parameters: */
    50         iomodel->Constant(&numberofelements,MeshNumberofelementsEnum);
    51         iomodel->Constant(&numberofvertices,MeshNumberofverticesEnum);
    5247        iomodel->Constant(&numberofelements2d,MeshNumberofelements2dEnum);
    5348        iomodel->Constant(&numberofvertices2d,MeshNumberofvertices2dEnum);
    … …  
    6257        if(iomodel->dim==2){
    6358                elements_width=3; //tria elements
    64                 iomodel->FetchData(&elements,NULL,NULL,MeshElementsEnum);
    6559        }
    6660        else{
    … …  
    6963        }
    7064
    71         MeshPartitionx(&epart, &npart,numberofelements,numberofvertices,elements, numberofelements2d,numberofvertices2d,elements2d,numlayers,elements_width,iomodel->dim,num_procs);
     65        MeshPartitionx(&epart,&npart,iomodel->numberofelements,iomodel->numberofvertices,iomodel->elements,numberofelements2d,numberofvertices2d,elements2d,numlayers,elements_width,iomodel->dim,num_procs);
    7266
    73         /*Free elements and elements2d: */
    74         iomodel->DeleteData(elements,MeshElementsEnum);
    75         iomodel->DeleteData(elements2d,MeshElements2dEnum);
     67        /*Free elements2d: */
     68        xDelete<int>(elements2d);
    7669
    7770        /*Deal with rifts, they have to be included into one partition only, not several: */
    … …  
    8780
    8881        /*Used later on: */
    89         my_vertices=xNewZeroInit<int>(numberofvertices);
    90         my_elements=xNewZeroInit<bool>(numberofelements);
     82        my_vertices=xNewZeroInit<int>(iomodel->numberofvertices);
     83        my_elements=xNewZeroInit<bool>(iomodel->numberofelements);
    9184
    9285        /*Start figuring out, out of the partition, which elements belong to this cpu: */
    93         iomodel->FetchData(&elements,NULL,NULL,MeshElementsEnum);
    94         for (i=0;i<numberofelements;i++){
     86        for (i=0;i<iomodel->numberofelements;i++){
    9587
    9688                /*!All elements have been partitioned above, only deal with elements for this cpu: */
    … …  
    10395                         into the vertices coordinates. If we start plugging 1 into my_vertices for each index[n][i] (i=0:2), then my_vertices
    10496                         will hold which vertices belong to this partition*/
    105                         my_vertices[reCast<int>(*(elements+elements_width*i+0))-1]=1;
    106                         my_vertices[reCast<int>(*(elements+elements_width*i+1))-1]=1;
    107                         my_vertices[reCast<int>(*(elements+elements_width*i+2))-1]=1;
     97                        my_vertices[iomodel->elements[elements_width*i+0]-1]=1;
     98                        my_vertices[iomodel->elements[elements_width*i+1]-1]=1;
     99                        my_vertices[iomodel->elements[elements_width*i+2]-1]=1;
    108100
    109101                        if(elements_width==6){
    110                                 my_vertices[reCast<int>(*(elements+elements_width*i+3))-1]=1;
    111                                 my_vertices[reCast<int>(*(elements+elements_width*i+4))-1]=1;
    112                                 my_vertices[reCast<int>(*(elements+elements_width*i+5))-1]=1;
     102                                my_vertices[iomodel->elements[elements_width*i+3]-1]=1;
     103                                my_vertices[iomodel->elements[elements_width*i+4]-1]=1;
     104                                my_vertices[iomodel->elements[elements_width*i+5]-1]=1;
    113105                        }
    114106                }
    115         }//for (i=0;i<numberofelements;i++)
    116         /*Free data : */
    117         iomodel->DeleteData(elements,MeshElementsEnum);
     107        }
    118108
    119109        /*We might have vertex_pairing in which case, some vertices have to be cloned:
    … …  
    122112        iomodel->FetchData(&vertex_pairing,&numvertex_pairing,NULL,DiagnosticVertexPairingEnum);
    123113        for(i=0;i<numvertex_pairing;i++){
    124                 if(my_vertices[reCast<int>(vertex_pairing[2*i+0])-1] && !my_vertices[reCast<int>(vertex_pairing[2*i+1])-1]){
    125                         my_vertices[reCast<int>(vertex_pairing[2*i+1])-1]=2; //to know that these elements are not on the partition
     114                if(my_vertices[vertex_pairing[2*i+0]-1] && !my_vertices[vertex_pairing[2*i+1]-1]){
     115                        my_vertices[vertex_pairing[2*i+1]-1]=2; //to know that these elements are not on the partition
    126116                }
    127117        }
    128         iomodel->DeleteData(vertex_pairing,DiagnosticVertexPairingEnum);
     118        xDelete<int>(vertex_pairing);
    129119        iomodel->FetchData(&vertex_pairing,&numvertex_pairing,NULL,PrognosticVertexPairingEnum);
    130120        for(i=0;i<numvertex_pairing;i++){
    131                 if(my_vertices[reCast<int>(vertex_pairing[2*i+0])-1] && !my_vertices[reCast<int>(vertex_pairing[2*i+1])-1]){
    132                         my_vertices[reCast<int>(vertex_pairing[2*i+1])-1]=2; //to know that these elements are not on the partition
     121                if(my_vertices[vertex_pairing[2*i+0]-1] && !my_vertices[vertex_pairing[2*i+1]-1]){
     122                        my_vertices[vertex_pairing[2*i+1]-1]=2; //to know that these elements are not on the partition
    133123                }
    134124        }
    135         iomodel->DeleteData(vertex_pairing,PrognosticVertexPairingEnum);
     125        xDelete<int>(vertex_pairing);
    136126
    137127        /*Free ressources:*/

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

    r15423 r15428  
    1111
    1212        /*Intermediary*/
    13         int    i,j;
    14         int    count;
    15         int    M,N;
    16         int    numberofvertices;
    17         bool   spcpresent=false;
     13        int        i,j;
     14        int        count;
     15        int        M,N;
     16        bool       spcpresent = false;
    1817        IssmDouble heatcapacity;
    1918        IssmDouble referencetemperature;
    … …  
    2524
    2625        /*Fetch parameters: */
    27         iomodel->Constant(&numberofvertices,MeshNumberofverticesEnum);
    2826        iomodel->Constant(&heatcapacity,MaterialsHeatcapacityEnum);
    2927        iomodel->Constant(&referencetemperature,ConstantsReferencetemperatureEnum);
    … …  
    3634
    3735        /*return if 2d mesh*/
    38         if (iomodel->dim==2){
     36        if(iomodel->dim==2){
    3937                *pconstraints=constraints;
    4038                return;
    … …  
    4644        //FIX ME: SHOULD USE IOMODELCREATECONSTRAINTS
    4745        /*Transient or static?:*/
    48         if(M==numberofvertices){
     46        if(M==iomodel->numberofvertices){
    4947                /*static: just create Constraints objects*/
    5048                count=0;
    5149
    52                 for (i=0;i<numberofvertices;i++){
     50                for(int i=0;i<iomodel->numberofvertices;i++){
    5351                        /*keep only this partition's nodes:*/
    5452                        if((iomodel->my_vertices[i])){
    … …  
    6361                }
    6462        }
    65         else if (M==(numberofvertices+1)){
     63        else if (M==(iomodel->numberofvertices+1)){
    6664                /*transient: create transient SpcTransient objects. Same logic, except we need to retrieve
    6765                 * various times and values to initialize an SpcTransient object: */
    … …  
    7068                /*figure out times: */
    7169                times=xNew<IssmDouble>(N);
    72                 for(j=0;j<N;j++){
     70                for(int j=0;j<N;j++){
    7371                        times[j]=spcvector[(M-1)*N+j];
    7472                }
    7573
    7674                /*Create constraints from x,y,z: */
    77                 for (i=0;i<numberofvertices;i++){
     75                for(int i=0;i<iomodel->numberofvertices;i++){
    7876
    7977                        /*keep only this partition's nodes:*/
    … …  
    8381                                values=xNew<IssmDouble>(N);
    8482                                spcpresent=false;
    85                                 for(j=0;j<N;j++){
     83                                for(int j=0;j<N;j++){
    8684                                        values[j]=heatcapacity*(spcvector[i*N+j]-referencetemperature);
    8785                                        if(!xIsNan<IssmDouble>(values[j]))spcpresent=true; //NaN means no spc by default

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

    r15000 r15428  
    1212
    1313        /*Intermediary*/
    14         int i;
    1514        bool continuous_galerkin=true;
    16         int    numberofvertices;
    17 
    18         /*Fetch parameters: */
    19         iomodel->Constant(&numberofvertices,MeshNumberofverticesEnum);
    2015
    2116        /*Recover pointer: */
    … …  
    3126        iomodel->FetchData(6,MeshVertexonbedEnum,MeshVertexonsurfaceEnum,MaskVertexongroundediceEnum,MaskVertexonfloatingiceEnum,FlowequationVertexEquationEnum,MaskVertexonwaterEnum);
    3227
    33         for (i=0;i<numberofvertices;i++){
     28        for(int i=0;i<iomodel->numberofvertices;i++){
    3429                if(iomodel->my_vertices[i]){
    3530

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

    r15423 r15428  
    2020
    2121        /*Fetch data needed: */
    22         iomodel->FetchData(4,MeshElementsEnum,TemperatureEnum,WaterfractionEnum,PressureEnum);
     22        iomodel->FetchData(3,TemperatureEnum,WaterfractionEnum,PressureEnum);
    2323
    2424        /*Update elements: */
    … …  
    5454
    5555        /*Free data: */
    56         iomodel->DeleteData(4,MeshElementsEnum,TemperatureEnum,WaterfractionEnum,PressureEnum);
     56        iomodel->DeleteData(3,TemperatureEnum,WaterfractionEnum,PressureEnum);
    5757}

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

    r15000 r15428  
    1212
    1313        /*Intermediary*/
    14         int i;
    1514        bool continuous_galerkin=true;
    16 
    17         /*Fetch parameters: */
    18         int    numberofvertices;
    19         iomodel->Constant(&numberofvertices,MeshNumberofverticesEnum);
    2015
    2116        /*Recover pointer: */
    … …  
    3227
    3328        /*First fetch data: */
    34         for (i=0;i<numberofvertices;i++){
     29        for(int i=0;i<iomodel->numberofvertices;i++){
    3530                if(iomodel->my_vertices[i]){
    3631

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

    r15423 r15428  
    1111void    UpdateElementsGia(Elements* elements, IoModel* iomodel,int analysis_counter,int analysis_type){
    1212
    13         int    numberofelements;
    14 
    15         /*Fetch parameters: */
    16         iomodel->Constant(&numberofelements,MeshNumberofelementsEnum);
    17 
    18         /*Fetch data needed: */
    19         iomodel->FetchData(1,MeshElementsEnum);
    20 
    2113        /*Update elements: */
    2214        int counter=0;
    23         for(int i=0;i<numberofelements;i++){
     15        for(int i=0;i<iomodel->numberofelements;i++){
    2416                if(iomodel->my_elements[i]){
    2517                        Element* element=(Element*)elements->GetObjectByOffset(counter);
    … …  
    3325        iomodel->FetchDataToInput(elements,GiaLithosphereThicknessEnum);
    3426
    35         /*Free data: */
    36         iomodel->DeleteData(1,MeshElementsEnum);
    37 
    3827}

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

    r15000 r15428  
    1010
    1111        /*Intermediary*/
    12         bool     isefficientlayer;
    13         int      hydrology_model;
    14         int      numberofvertices;
    15         Pengrid *pengrid = NULL;
     12        bool isefficientlayer;
     13        int  hydrology_model;
    1614
    1715        /*Recover pointer: */
    1816        Loads* loads=*ploads;
    19 
    20         /*Fetch parameters: */
    21         iomodel->Constant(&numberofvertices,MeshNumberofverticesEnum);
    2217
    2318        /*Create loads if they do not exist yet*/

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

    r15000 r15428  
    1212
    1313        /*Intermediary*/
    14         int  i;
    1514        bool isefficientlayer;
    1615        bool continuous_galerkin=true;
    1716        int  hydrology_model;
    18         int  numberofvertices;
    19 
    20         /*Fetch parameters: */
    21         iomodel->Constant(&numberofvertices,MeshNumberofverticesEnum);
    2217
    2318        /*Recover pointer: */
    … …  
    4641        /*Create nodes and vertices: */
    4742        iomodel->FetchData(6,MeshVertexonbedEnum,MeshVertexonsurfaceEnum,MaskVertexongroundediceEnum,MaskVertexonfloatingiceEnum,FlowequationVertexEquationEnum,MaskVertexonwaterEnum);
    48         for (i=0;i<numberofvertices;i++){
     43        for(int i=0;i<iomodel->numberofvertices;i++){
    4944
    5045                if(iomodel->my_vertices[i]){

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

    r15000 r15428  
    1313        bool   isefficientlayer;
    1414        int    hydrology_model;
    15         int    numberofelements;
    16 
    17         /*Fetch data needed: */
    18         iomodel->Constant(&numberofelements,MeshNumberofelementsEnum);
    1915
    2016        /*Now, do we really want DC?*/
    … …  
    2622        if(!isefficientlayer) return;
    2723
    28         /*Fetch data needed: */
    29         iomodel->FetchData(1,MeshElementsEnum);
    30 
    3124        /*Update elements: */
    3225        int counter=0;
    33         for(int i=0;i<numberofelements;i++){
     26        for(int i=0;i<iomodel->numberofelements;i++){
    3427                if(iomodel->my_elements[i]){
    3528                        Element* element=(Element*)elements->GetObjectByOffset(counter);
    … …  
    4841        iomodel->FetchDataToInput(elements,BasalforcingsMeltingRateEnum);
    4942        iomodel->FetchDataToInput(elements,EplHeadEnum);
    50 
    51         /*Free data: */
    52         iomodel->DeleteData(1,MeshElementsEnum);
    5343}

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

    r15000 r15428  
    1111        /*Intermediary*/
    1212        int      hydrology_model;
    13         int      numberofvertices;
    14         Pengrid *pengrid = NULL;
    1513
    1614        /*Recover pointer: */
    … …  
    1917        /*Fetch parameters: */
    2018        iomodel->Constant(&hydrology_model,HydrologyModelEnum);
    21         iomodel->Constant(&numberofvertices,MeshNumberofverticesEnum);
    2219
    2320        /*Create loads if they do not exist yet*/
    … …  
    3027
    3128        //create penalties for nodes: no node can have a temperature over the melting point
    32         iomodel->FetchData(1,MeshElementsEnum);
    3329        CreateSingleNodeToElementConnectivity(iomodel);
    34 
    35         for(int i=0;i<numberofvertices;i++){
     30        for(int i=0;i<iomodel->numberofvertices;i++){
    3631                /*keep only this partition's nodes:*/
    3732                if((iomodel->my_vertices[i]==1)){
    … …  
    3934                }
    4035        }
    41         iomodel->DeleteData(1,MeshElementsEnum);
    4236
    4337        /*Assign output pointer: */

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

    r15000 r15428  
    1212
    1313        /*Intermediary*/
    14         int  i;
    1514        bool continuous_galerkin=true;
    1615        int  hydrology_model;
    17         int  numberofvertices;
    1816
    1917        /*Fetch parameters: */
    20         iomodel->Constant(&numberofvertices,MeshNumberofverticesEnum);
    2118        iomodel->Constant(&hydrology_model,HydrologyModelEnum);
    2219
    … …  
    3835        /*Create nodes and vertices: */
    3936        iomodel->FetchData(6,MeshVertexonbedEnum,MeshVertexonsurfaceEnum,MaskVertexongroundediceEnum,MaskVertexonfloatingiceEnum,FlowequationVertexEquationEnum,MaskVertexonwaterEnum);
    40         for (i=0;i<numberofvertices;i++){
     37        for(int i=0;i<iomodel->numberofvertices;i++){
    4138
    4239                if(iomodel->my_vertices[i]){

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

    r15195 r15428  
    1313        bool   isefficientlayer;
    1414        int    hydrology_model;
    15         int    numberofelements;
    1615
    1716        /*Fetch data needed: */
    1817        iomodel->Constant(&hydrology_model,HydrologyModelEnum);
    19         iomodel->Constant(&numberofelements,MeshNumberofelementsEnum);
    2018
    2119        /*Now, do we really want DC?*/
    … …  
    2422        /*Fetch data needed: */
    2523        iomodel->Constant(&isefficientlayer,HydrologydcIsefficientlayerEnum);
    26         iomodel->FetchData(1,MeshElementsEnum);
    2724
    2825        /*Update elements: */
    2926        int counter=0;
    30         for(int i=0;i<numberofelements;i++){
     27        for(int i=0;i<iomodel->numberofelements;i++){
    3128                if(iomodel->my_elements[i]){
    3229                        Element* element=(Element*)elements->GetObjectByOffset(counter);
    … …  
    4643        iomodel->FetchDataToInput(elements,SedimentHeadEnum);
    4744        if(isefficientlayer)iomodel->FetchDataToInput(elements,HydrologydcMaskEplactiveEnum);
    48 
    49         /*Free data: */
    50         iomodel->DeleteData(1,MeshElementsEnum);
    5145}

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

    r15000 r15428  
    1212
    1313        /*Intermediary*/
    14         int  i;
    1514        int  hydrology_model;
    1615        bool continuous_galerkin=true;
    17         int  numberofvertices;
    1816
    1917        /*Fetch parameters: */
    20         iomodel->Constant(&numberofvertices,MeshNumberofverticesEnum);
    2118        iomodel->Constant(&hydrology_model,HydrologyModelEnum);
    2219
    … …  
    3835        /*Create nodes and vertices: */
    3936        iomodel->FetchData(6,MeshVertexonbedEnum,MeshVertexonsurfaceEnum,MaskVertexongroundediceEnum,MaskVertexonfloatingiceEnum,FlowequationVertexEquationEnum,MaskVertexonwaterEnum);
    40         for (i=0;i<numberofvertices;i++){
     37        for(int i=0;i<iomodel->numberofvertices;i++){
    4138
    4239                if(iomodel->my_vertices[i]){

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

    r15000 r15428  
    1212
    1313        int    hydrology_model;
    14         int    numberofelements;
    1514
    1615        /*Fetch data needed: */
    1716        iomodel->Constant(&hydrology_model,HydrologyModelEnum);
    18         iomodel->Constant(&numberofelements,MeshNumberofelementsEnum);
    1917
    2018        /*Now, do we really want Shreve?*/
    2119        if(hydrology_model!=HydrologyshreveEnum) return;
    2220
    23         /*Fetch data needed: */
    24         iomodel->FetchData(1,MeshElementsEnum);
    25 
    2621        /*Update elements: */
    2722        int counter=0;
    28         for(int i=0;i<numberofelements;i++){
     23        for(int i=0;i<iomodel->numberofelements;i++){
    2924                if(iomodel->my_elements[i]){
    3025                        Element* element=(Element*)elements->GetObjectByOffset(counter);
    … …  
    4641        elements->InputDuplicate(WatercolumnEnum,WaterColumnOldEnum);
    4742
    48         /*Free data: */
    49         iomodel->DeleteData(1,MeshElementsEnum);
    5043}

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

    r15423 r15428  
    88
    99void    CreateLoadsMelting(Loads** ploads, IoModel* iomodel){
    10 
    11         /*Intermediary*/
    12         int numberofvertices;
    13         iomodel->Constant(&numberofvertices,MeshNumberofverticesEnum);
    1410
    1511        /*if 2d: Error*/
    … …  
    2319
    2420        //create penalties for nodes: no node can have a temperature over the melting point
    25         iomodel->FetchData(2,MeshVertexonbedEnum,MeshElementsEnum);
     21        iomodel->FetchData(1,MeshVertexonbedEnum);
    2622        CreateSingleNodeToElementConnectivity(iomodel);
    2723
    28         for(int i=0;i<numberofvertices;i++){
     24        for(int i=0;i<iomodel->numberofvertices;i++){
    2925                if((iomodel->my_vertices[i]==1)){
    3026                        if (reCast<int>(iomodel->Data(MeshVertexonbedEnum)[i])){
    … …  
    3329                }
    3430        }
    35         iomodel->DeleteData(2,MeshVertexonbedEnum,MeshElementsEnum);
     31        iomodel->DeleteData(1,MeshVertexonbedEnum);
    3632
    3733        /*Assign output pointer: */

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

    r15000 r15428  
    1212
    1313        /*Intermediary*/
    14         int i;
    1514        bool continuous_galerkin=true;
    16         int    numberofvertices;
    17 
    18         /*Fetch parameters: */
    19         iomodel->Constant(&numberofvertices,MeshNumberofverticesEnum);
    2015
    2116        /*Recover pointer: */
    … …  
    3025        /*First fetch data: */
    3126        iomodel->FetchData(6,MeshVertexonbedEnum,MeshVertexonsurfaceEnum,MaskVertexongroundediceEnum,MaskVertexonfloatingiceEnum,FlowequationVertexEquationEnum,MaskVertexonwaterEnum);
    32         for (i=0;i<numberofvertices;i++){
     27        for(int i=0;i<iomodel->numberofvertices;i++){
    3328
    3429                if(iomodel->my_vertices[i]){

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

    r15423 r15428  
    1111void    UpdateElementsMelting(Elements* elements, IoModel* iomodel,int analysis_counter,int analysis_type){
    1212
    13         int    numberofelements;
    14 
    15         /*Fetch parameters: */
    16         iomodel->Constant(&numberofelements,MeshNumberofelementsEnum);
    17 
    1813        /*Now, is the model 3d? otherwise, do nothing: */
    1914        if(iomodel->dim==2)return;
    2015
    21         /*Fetch data needed: */
    22         iomodel->FetchData(1,MeshElementsEnum);
    23 
    2416        /*Update elements: */
    2517        int counter=0;
    26         for(int i=0;i<numberofelements;i++){
     18        for(int i=0;i<iomodel->numberofelements;i++){
    2719                if(iomodel->my_elements[i]){
    2820                        Element* element=(Element*)elements->GetObjectByOffset(counter);
    … …  
    4840        iomodel->FetchDataToInput(elements,BasalforcingsMeltingRateEnum);
    4941        iomodel->FetchDataToInput(elements,PressureEnum);
    50 
    51         /*Free data: */
    52         iomodel->DeleteData(1,MeshElementsEnum);
    5342}

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

    r15423 r15428  
    3232void  ContinuousGalerkinNodesPartitioning(bool** pmy_nodes,bool* my_elements, int* my_vertices, IoModel* iomodel){
    3333
    34         /*as many nodes as there are vertices */
    35         int    numberofvertices;
    36 
    3734        /*output: */
    38         bool* my_nodes=NULL;
    39 
    40         /*Fetch parameters: */
    41         iomodel->Constant(&numberofvertices,MeshNumberofverticesEnum);
    42 
    43         my_nodes=xNew<bool>(numberofvertices);
    44         for(int i=0;i<numberofvertices;i++) my_nodes[i]=(bool)my_vertices[i];
     35        bool* my_nodes=xNew<bool>(iomodel->numberofvertices);
     36        for(int i=0;i<iomodel->numberofvertices;i++) my_nodes[i]=(bool)my_vertices[i];
    4537
    4638        /*Assign output pointers:*/
    … …  
    4941
    5042void  DiscontinuousGalerkinNodesPartitioning(bool** pmy_nodes,bool* my_elements, int* my_vertices, IoModel* iomodel){
    51 
    52         int    numberofelements;
    53 
    54         /*Fetch parameters: */
    55         iomodel->Constant(&numberofelements,MeshNumberofelementsEnum);
    5643
    5744        /*each element has it own nodes (as many as vertices) + additional nodes from neighbouring elements for each edge. This yields to a very different partition for
    … …  
    8067
    8168        /*Allocate*/
    82         my_nodes=xNewZeroInit<bool>(3*numberofelements);
     69        my_nodes=xNewZeroInit<bool>(3*iomodel->numberofelements);
    8370
    8471        /*First: add all the nodes of all the elements belonging to this cpu*/
    8572        if (iomodel->dim==2){
    86                 for (i=0;i<numberofelements;i++){
     73                for (i=0;i<iomodel->numberofelements;i++){
    8774                        if (my_elements[i]){
    8875                                my_nodes[3*i+0]=true;
    … …  
    10087        /*Get edges and elements*/
    10188        iomodel->FetchData(&edges,&numberofedges,&cols,MeshEdgesEnum);
    102         iomodel->FetchData(&elements,NULL,NULL,MeshElementsEnum);
    10389        if (cols!=4) _error_("field edges should have 4 columns");
    10490
    … …  
    124110                        pos=UNDEF;
    125111                        for(int j=0;j<3;j++){
    126                                 if (elements[3*e2+j]==i1) pos=j;
     112                                if(iomodel->elements[3*e2+j]==i1) pos=j;
    127113                        }
    128114
    … …  
    148134
    149135        /*Free data: */
    150         xDelete<int>(elements);
    151136        xDelete<int>(edges);
    152137

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

    r15000 r15428  
    1717        int numberofedges;
    1818        int numvertex_pairing;
    19         int numberofelements;
    2019
    2120        /*Fetch parameters: */
    2221        iomodel->Constant(&stabilization,PrognosticStabilizationEnum);
    23         iomodel->Constant(&numberofelements,MeshNumberofelementsEnum);
    2422        iomodel->Constant(&numberofedges,MeshNumberofedgesEnum);
    2523
    … …  
    3432
    3533                /*Get edges and elements*/
    36                 iomodel->FetchData(3,MeshEdgesEnum,MeshElementsEnum,ThicknessEnum);
     34                iomodel->FetchData(2,MeshEdgesEnum,ThicknessEnum);
    3735
    3836                /*First load data:*/
    … …  
    5048
    5149                /*Free data: */
    52                 iomodel->DeleteData(3,MeshEdgesEnum,MeshElementsEnum,ThicknessEnum);
     50                iomodel->DeleteData(2,MeshEdgesEnum,ThicknessEnum);
    5351        }
    5452

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

    r15423 r15428  
    1717        int  io_index;
    1818        bool continuous_galerkin=true;
    19         int    numberofelements;
    20         int    numberofvertices;
    21         int    stabilization;
     19        int  stabilization;
    2220
    2321        /*Fetch parameters: */
    24         iomodel->Constant(&numberofelements,MeshNumberofelementsEnum);
    25         iomodel->Constant(&numberofvertices,MeshNumberofverticesEnum);
    2622        iomodel->Constant(&stabilization,PrognosticStabilizationEnum);
    2723
    … …  
    4036
    4137        /*First fetch data: */
    42         iomodel->FetchData(7,MeshElementsEnum,MeshVertexonbedEnum,MeshVertexonsurfaceEnum,MaskVertexongroundediceEnum,MaskVertexonfloatingiceEnum,FlowequationVertexEquationEnum,MaskVertexonwaterEnum);
     38        iomodel->FetchData(6,MeshVertexonbedEnum,MeshVertexonsurfaceEnum,MaskVertexongroundediceEnum,MaskVertexonfloatingiceEnum,FlowequationVertexEquationEnum,MaskVertexonwaterEnum);
    4339        if(continuous_galerkin){
    4440
    4541                /*Build Nodes dataset (Continuous Galerkin)*/
    46                 for (i=0;i<numberofvertices;i++){
     42                for (i=0;i<iomodel->numberofvertices;i++){
    4743
    4844                        if(iomodel->my_vertices[i]){
    … …  
    5753
    5854                /*Build Nodes dataset -> 3 for each element (Discontinuous Galerkin)*/
    59                 for (i=0;i<numberofelements;i++){
     55                for (i=0;i<iomodel->numberofelements;i++){
    6056                        for (j=0;j<3;j++){
    6157
    … …  
    6359
    6460                                        //Get index of the vertex on which the current node is located
    65                                         vertex_id=reCast<int>(*(iomodel->Data(MeshElementsEnum)+3*i+j)); //(Matlab indexing)
    66                                         io_index=vertex_id-1;                      //(C indexing)
    67                                         _assert_(vertex_id>0 && vertex_id<=numberofvertices);
     61                                        vertex_id=iomodel->elements[+3*i+j]; //(Matlab indexing)
     62                                        io_index=vertex_id-1;                //(C indexing)
     63                                        _assert_(vertex_id>0 && vertex_id<=iomodel->numberofvertices);
    6864
    6965                                        //Compute Node id
    … …  
    7975
    8076        /*Clean fetched data: */
    81         iomodel->DeleteData(7,MeshElementsEnum,MeshVertexonbedEnum,MeshVertexonsurfaceEnum,MaskVertexongroundediceEnum,MaskVertexonfloatingiceEnum,FlowequationVertexEquationEnum,MaskVertexonwaterEnum);
     77        iomodel->DeleteData(6,MeshVertexonbedEnum,MeshVertexonsurfaceEnum,MaskVertexongroundediceEnum,MaskVertexonfloatingiceEnum,FlowequationVertexEquationEnum,MaskVertexonwaterEnum);
    8278
    8379        /*Assign output pointer: */

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

    r15423 r15428  
    2525        iomodel->Constant(&isdelta18o,SurfaceforcingsIsdelta18oEnum);
    2626        iomodel->Constant(&issmbgradients,SurfaceforcingsIssmbgradientsEnum);
    27         iomodel->FetchData(1,MeshElementsEnum);
    2827
    2928        /*Update elements: */
    … …  
    9493                iomodel->FetchDataToInput(elements,SurfaceforcingsMassBalanceEnum);
    9594        }
    96 
    97         /*Free data: */
    98         iomodel->DeleteData(1,MeshElementsEnum);
    9995}

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

    r15000 r15428  
    1313        /*Intermediary*/
    1414        bool continuous_galerkin=true;
    15         int    numberofvertices;
    16 
    17         /*Fetch parameters: */
    18         iomodel->Constant(&numberofvertices,MeshNumberofverticesEnum);
    1915
    2016        /*Recover pointer: */
    … …  
    3026        iomodel->FetchData(6,MeshVertexonbedEnum,MeshVertexonsurfaceEnum,MaskVertexongroundediceEnum,MaskVertexonfloatingiceEnum,FlowequationVertexEquationEnum,MaskVertexonwaterEnum);
    3127
    32         for(int i=0;i<numberofvertices;i++){
     28        for(int i=0;i<iomodel->numberofvertices;i++){
    3329                if(iomodel->my_vertices[i]){
    3430

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

    r15423 r15428  
    1111void    UpdateElementsSurfaceSlope(Elements* elements, IoModel* iomodel,int analysis_counter,int analysis_type){
    1212
    13         int    numberofelements;
    14 
    15         /*Fetch data needed: */
    16         iomodel->Constant(&numberofelements,MeshNumberofelementsEnum);
    17         iomodel->FetchData(1,MeshElementsEnum);
    18 
    1913        /*Update elements: */
    2014        int counter=0;
    21         for(int i=0;i<numberofelements;i++){
     15        for(int i=0;i<iomodel->numberofelements;i++){
    2216                if(iomodel->my_elements[i]){
    2317                        Element* element=(Element*)elements->GetObjectByOffset(counter);
    … …  
    3529                iomodel->FetchDataToInput(elements,MeshElementonsurfaceEnum);
    3630        }
    37 
    38         /*Free data: */
    39         iomodel->DeleteData(1,MeshElementsEnum);
    4031}

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

    r15423 r15428  
    99void    CreateLoadsThermal(Loads** ploads, IoModel* iomodel){
    1010
    11         /*Intermediary*/
    12         int      numberofvertices;
    13         Pengrid *pengrid          = NULL;
    14 
    1511        /*Recover pointer: */
    1612        Loads* loads=*ploads;
    … …  
    1814        if(iomodel->dim==2) _error_("2d meshes not supported yet");
    1915
    20         /*Fetch parameters: */
    21         iomodel->Constant(&numberofvertices,MeshNumberofverticesEnum);
    22 
    2316        /*Create loads if they do not exist yet*/
    2417        if(!loads) loads = new Loads();
    2518
    2619        //create penalties for nodes: no node can have a temperature over the melting point
    27         iomodel->FetchData(2,ThermalSpctemperatureEnum,MeshElementsEnum);
     20        iomodel->FetchData(1,ThermalSpctemperatureEnum);
    2821        CreateSingleNodeToElementConnectivity(iomodel);
    2922
    30         for(int i=0;i<numberofvertices;i++){
     23        for(int i=0;i<iomodel->numberofvertices;i++){
    3124
    3225                /*keep only this partition's nodes:*/
    … …  
    3730                }
    3831        }
    39         iomodel->DeleteData(2,ThermalSpctemperatureEnum,MeshElementsEnum);
     32        iomodel->DeleteData(1,ThermalSpctemperatureEnum);
    4033
    4134        /*Assign output pointer: */

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

    r15000 r15428  
    1414        bool continuous_galerkin=true;
    1515
    16         /*Fetch parameters: */
    17         int    numberofvertices;
    18         iomodel->Constant(&numberofvertices,MeshNumberofverticesEnum);
    19 
    2016        /*Recover pointer: */
    2117        Nodes* nodes=*pnodes;
    … …  
    3026        iomodel->FetchData(6,MeshVertexonbedEnum,MeshVertexonsurfaceEnum,MaskVertexongroundediceEnum,MaskVertexonfloatingiceEnum,FlowequationVertexEquationEnum,MaskVertexonwaterEnum);
    3127
    32         for(int i=0;i<numberofvertices;i++){
     28        for(int i=0;i<iomodel->numberofvertices;i++){
    3329                if(iomodel->my_vertices[i]){
    3430                        /*Add node to nodes dataset: */

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

    r15423 r15428  
    1111void    UpdateElementsThermal(Elements* elements, IoModel* iomodel,int analysis_counter,int analysis_type){
    1212
    13         int    numberofelements;
    14         bool   dakota_analysis;
    15 
    1613        /*Now, is the model 3d? otherwise, do nothing: */
    1714        if(iomodel->dim==2)return;
    1815
    19         /*Fetch parameters: */
    20         iomodel->Constant(&numberofelements,MeshNumberofelementsEnum);
    21         iomodel->Constant(&dakota_analysis,QmuIsdakotaEnum);
    22 
    23         /*Fetch data needed: */
    24         iomodel->FetchData(1,MeshElementsEnum);
    25 
    2616        /*Update elements: */
    2717        int counter=0;
    28         for(int i=0;i<numberofelements;i++){
     18        for(int i=0;i<iomodel->numberofelements;i++){
    2919                if(iomodel->my_elements[i]){
    3020                        Element* element=(Element*)elements->GetObjectByOffset(counter);
    … …  
    5444        iomodel->FetchDataToInput(elements,VzEnum);
    5545
     46        bool dakota_analysis;
     47        iomodel->Constant(&dakota_analysis,QmuIsdakotaEnum);
    5648        if(dakota_analysis){
    5749                elements->InputDuplicate(TemperatureEnum,QmuTemperatureEnum);
    … …  
    5951                elements->InputDuplicate(BasalforcingsMeltingRateEnum,QmuMeltingEnum);
    6052        }
    61 
    62         /*Free data: */
    63         iomodel->DeleteData(1,MeshElementsEnum);
    6453}

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

    r15000 r15428  
    1313        bool        isgl;
    1414        int         migration_style;
    15         int         i,numberofvertices;
    1615        IssmDouble  rho_ice,rho_water;
    1716        IssmDouble *phi   = NULL;
    … …  
    2625                iomodel->Constant(&rho_ice,MaterialsRhoIceEnum);
    2726                iomodel->Constant(&rho_water,MaterialsRhoWaterEnum);
    28                 iomodel->Constant(&numberofvertices,MeshNumberofverticesEnum);
    29                 iomodel->FetchData(3,MeshElementsEnum,ThicknessEnum,BathymetryEnum);
     27                iomodel->FetchData(2,ThicknessEnum,BathymetryEnum);
    3028
    3129                /*Create phi vector */
    32                 phi=xNew<IssmDouble>(numberofvertices);
    33                 for (i=0;i<numberofvertices;i++){
     30                phi=xNew<IssmDouble>(iomodel->numberofvertices);
     31                for(int i=0;i<iomodel->numberofvertices;i++){
    3432                        if(iomodel->my_vertices[i]){
    3533                                phi[i] = iomodel->Data(ThicknessEnum)[i] + rho_water/rho_ice * iomodel->Data(BathymetryEnum)[i];
    … …  
    3836
    3937                /*Update elements: */
    40                 for(i=0;i<elements->Size();i++){
     38                for(int i=0;i<elements->Size();i++){
    4139                        Element* element=dynamic_cast<Element*>(elements->GetObjectByOffset(i));
    42                         element->InputCreate(phi,element->Sid(),iomodel,numberofvertices,1,1,GLlevelsetEnum,1);
     40                        element->InputCreate(phi,element->Sid(),iomodel,iomodel->numberofvertices,1,1,GLlevelsetEnum,1);
    4341                }
    4442
    4543                /*Free ressources:*/
    46                 iomodel->DeleteData(3,MeshElementsEnum,ThicknessEnum,BathymetryEnum);
     44                iomodel->DeleteData(2,ThicknessEnum,BathymetryEnum);
    4745                xDelete<IssmDouble>(phi);
    4846        }

  • issm/trunk-jpl/src/wrappers/MeshPartition/MeshPartition.cpp

    r15106 r15428  
    2222        int     numberofelements;
    2323        int     numberofvertices;
    24         double *elements         = NULL;
     24        int    *elements         = NULL;
    2525        int     elements_width;
    2626
    2727        int numberofelements2d;
    2828        int numberofvertices2d;
    29         double* elements2d=NULL;
     29        int* elements2d=NULL;
    3030
    3131        int numberoflayers;
Note: See TracChangeset for help on using the changeset viewer.