Changeset 23167


Ignore:
Timestamp:
08/23/18 11:09:21 (7 years ago)
Author:
Mathieu Morlighem
Message:

CHG: moving my_edges and my_faces to iomodel to avoid recomputation

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

Legend:

Unmodified
Added
Removed

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

    r23066 r23167  
    130130
    131131        this->my_elements=NULL;
     132        this->my_faces=NULL;
     133        this->my_edges=NULL;
    132134        this->my_vertices=NULL;
    133135
    … …  
    192194        /*Initialize permanent data: */
    193195        this->my_elements = NULL;
     196        this->my_faces = NULL;
     197        this->my_edges = NULL;
    194198        this->my_vertices = NULL;
    195199
    … …  
    236240
    237241        xDelete<bool>(this->my_elements);
     242        xDelete<bool>(this->my_faces);
     243        xDelete<bool>(this->my_edges);
    238244        xDelete<int>(this->my_vertices);
    239245

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

    r22004 r23167  
    6464                /*Partitioning*/
    6565                bool *my_elements;
     66                bool *my_faces;
     67                bool *my_edges;
    6668                int  *my_vertices;
    6769

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

    r22362 r23167  
    6262        /*Higher-order finite elements*/
    6363        int   v1,v2;
    64         bool *my_edges = NULL;
    65         bool *my_faces = NULL;
    6664        bool *boundaryedge = NULL;
    6765
    … …  
    8482                case P1xP3Enum:
    8583                case P1xP4Enum:
    86                         EdgesPartitioning(&my_edges,iomodel);
     84                        EdgesPartitioning(iomodel);
    8785                        break;
    8886                case P2xP1Enum:
    89                         EdgesPartitioning(&my_edges,iomodel);
     87                        EdgesPartitioning(iomodel);
    9088                        break;
    9189                case P2Enum:
    92                         EdgesPartitioning(&my_edges,iomodel);
    93               if(iomodel->meshelementtype==PentaEnum){
    94                                 FacesPartitioning(&my_faces,iomodel);
    95                         }
     90                        EdgesPartitioning(iomodel);
     91              if(iomodel->meshelementtype==PentaEnum) FacesPartitioning(iomodel);
    9692                        EdgeOnBoundaryFlags(&boundaryedge,iomodel);
    9793                        break;
    9894                case P2bubbleEnum:
    99                         EdgesPartitioning(&my_edges,iomodel);
     95                        EdgesPartitioning(iomodel);
    10096                        if(iomodel->meshelementtype==PentaEnum){
    101                                 FacesPartitioning(&my_faces,iomodel);
     97                                FacesPartitioning(iomodel);
    10298                        }
    10399                        EdgeOnBoundaryFlags(&boundaryedge,iomodel);
    … …  
    110106                        break;
    111107                case P2xP4Enum:
    112                         EdgesPartitioning(&my_edges,iomodel);
    113                         FacesPartitioning(&my_faces,iomodel);
     108                        EdgesPartitioning(iomodel);
     109                        FacesPartitioning(iomodel);
    114110                        break;
    115111                default:
    … …  
    140136                                }
    141137                                for(i=0;i<iomodel->numberofedges;i++){
    142                                         if(my_edges[i] && boundaryedge[i]){
     138                                        if(iomodel->my_edges[i] && boundaryedge[i]){
    143139                                                v1 = iomodel->edges[3*i+0]-1;
    144140                                                v2 = iomodel->edges[3*i+1]-1;
    … …  
    153149                                        for(i=0;i<iomodel->numberoffaces;i++){
    154150                                                if(iomodel->faces[i*iomodel->facescols+2]==2){/*Vertical quads*/
    155                                                         if(my_faces[i]){
     151                                                        if(iomodel->my_faces[i]){
    156152                                                                numfacevertices = iomodel->faces[i*iomodel->facescols+3];
    157153                                                                value=0.;
    … …  
    181177                                }
    182178                                for(i=0;i<iomodel->numberofedges;i++){
    183                                         if(my_edges[i] && boundaryedge[i]){
     179                                        if(iomodel->my_edges[i] && boundaryedge[i]){
    184180                                                v1 = iomodel->edges[3*i+0]-1;
    185181                                                v2 = iomodel->edges[3*i+1]-1;
    … …  
    194190                                        for(i=0;i<iomodel->numberoffaces;i++){
    195191                                                if(iomodel->faces[i*iomodel->facescols+2]==2){/*Vertical quads*/
    196                                                         if(my_faces[i]){
     192                                                        if(iomodel->my_faces[i]){
    197193                                                                numfacevertices = iomodel->faces[i*iomodel->facescols+3];
    198194                                                                value=0.;
    … …  
    238234                                for(i=0;i<iomodel->numberofedges;i++){
    239235                                        if(iomodel->edges[i*3+2]==2){/*Vertical edges*/
    240                                                 if(my_edges[i]){
     236                                                if(iomodel->my_edges[i]){
    241237                                                        v1 = iomodel->edges[3*i+0]-1;
    242238                                                        v2 = iomodel->edges[3*i+1]-1;
    … …  
    253249                                        }
    254250                                        if(iomodel->edges[i*3+2]==1){/*Horizontal edges*/
    255                                                 if(my_edges[i]){
     251                                                if(iomodel->my_edges[i]){
    256252                                                        v1 = iomodel->edges[3*i+0]-1;
    257253                                                        v2 = iomodel->edges[3*i+1]-1;
    … …  
    266262                                for(i=0;i<iomodel->numberoffaces;i++){
    267263                                        if(iomodel->faces[i*iomodel->facescols+2]==2){/*Vertical quads*/
    268                                                 if(my_faces[i]){
     264                                                if(iomodel->my_faces[i]){
    269265                                                        numfacevertices = iomodel->faces[i*iomodel->facescols+3];
    270266                                                        value=0.;
    … …  
    332328                                for(i=0;i<iomodel->numberofedges;i++){
    333329                                        if(iomodel->edges[i*3+2]==2){
    334                                                 if(my_edges[i]){
     330                                                if(iomodel->my_edges[i]){
    335331                                                        v1 = iomodel->edges[3*i+0]-1;
    336332                                                        v2 = iomodel->edges[3*i+1]-1;
    … …  
    355351                                for(i=0;i<iomodel->numberofedges;i++){
    356352                                        if(iomodel->edges[i*3+2]==2){
    357                                                 if(my_edges[i]){
     353                                                if(iomodel->my_edges[i]){
    358354                                                        v1 = iomodel->edges[3*i+0]-1;
    359355                                                        v2 = iomodel->edges[3*i+1]-1;
    … …  
    380376                                for(i=0;i<iomodel->numberofedges;i++){
    381377                                        if(iomodel->edges[i*3+2]==2){/*Vertical edges*/
    382                                                 if(my_edges[i]){
     378                                                if(iomodel->my_edges[i]){
    383379                                                        v1 = iomodel->edges[3*i+0]-1;
    384380                                                        v2 = iomodel->edges[3*i+1]-1;
    … …  
    407403                                for(i=0;i<iomodel->numberofedges;i++){
    408404                                        if(iomodel->edges[i*3+2]!=2){
    409                                                 if(my_edges[i]){
     405                                                if(iomodel->my_edges[i]){
    410406                                                        v1 = iomodel->edges[3*i+0]-1;
    411407                                                        v2 = iomodel->edges[3*i+1]-1;
    … …  
    472468                                }
    473469                                for(i=0;i<iomodel->numberofedges;i++){
    474                                         if(my_edges[i]){
     470                                        if(iomodel->my_edges[i]){
    475471                                                v1 = iomodel->edges[3*i+0]-1;
    476472                                                v2 = iomodel->edges[3*i+1]-1;
    … …  
    511507                                for(i=0;i<iomodel->numberofedges;i++){
    512508                                        if(iomodel->edges[i*3+2]==2){
    513                                                 if(my_edges[i]){
     509                                                if(iomodel->my_edges[i]){
    514510                                                        v1 = iomodel->edges[3*i+0]-1;
    515511                                                        v2 = iomodel->edges[3*i+1]-1;
    … …  
    551547                                for(i=0;i<iomodel->numberofedges;i++){
    552548                                        if(iomodel->edges[i*3+2]==2){
    553                                                 if(my_edges[i]){
     549                                                if(iomodel->my_edges[i]){
    554550                                                        v1 = iomodel->edges[3*i+0]-1;
    555551                                                        v2 = iomodel->edges[3*i+1]-1;
    … …  
    601597                                for(i=0;i<iomodel->numberofedges;i++){
    602598                                        if(iomodel->edges[i*3+2]!=2){
    603                                                 if(my_edges[i]){
     599                                                if(iomodel->my_edges[i]){
    604600                                                        v1 = iomodel->edges[3*i+0]-1;
    605601                                                        v2 = iomodel->edges[3*i+1]-1;
    … …  
    634630        xDelete<IssmDouble>(times);
    635631        xDelete<IssmDouble>(values);
    636         xDelete<bool>(my_edges);
    637         xDelete<bool>(my_faces);
    638632        xDelete<bool>(boundaryedge);
    639633}/*}}}*/
    … …  
    649643        /*Higher-order finite elements*/
    650644        int   v1,v2;
    651         bool *my_edges = NULL;
    652         bool *my_faces = NULL;
    653645        bool *boundaryedge = NULL;
    654646
    … …  
    669661                        break;
    670662                case P1xP2Enum:
    671                         EdgesPartitioning(&my_edges,iomodel);
     663                        EdgesPartitioning(iomodel);
    672664                        break;
    673665                case P1xP3Enum:
    674                         EdgesPartitioning(&my_edges,iomodel);
     666                        EdgesPartitioning(iomodel);
    675667                        break;
    676668                case P2xP1Enum:
    677                         EdgesPartitioning(&my_edges,iomodel);
     669                        EdgesPartitioning(iomodel);
    678670                        break;
    679671                case P2Enum:
    680                         EdgesPartitioning(&my_edges,iomodel);
     672                        EdgesPartitioning(iomodel);
    681673                        if(iomodel->meshelementtype==PentaEnum){
    682                                 FacesPartitioning(&my_faces,iomodel);
     674                                FacesPartitioning(iomodel);
    683675                        }
    684676                        EdgeOnBoundaryFlags(&boundaryedge,iomodel);
    685677                        break;
    686678                case P2bubbleEnum:
    687                         EdgesPartitioning(&my_edges,iomodel);
     679                        EdgesPartitioning(iomodel);
    688680                        if(iomodel->meshelementtype==PentaEnum){
    689                                 FacesPartitioning(&my_faces,iomodel);
     681                                FacesPartitioning(iomodel);
    690682                        }
    691683                        EdgeOnBoundaryFlags(&boundaryedge,iomodel);
    … …  
    698690                        break;
    699691                case P2xP4Enum:
    700                         EdgesPartitioning(&my_edges,iomodel);
    701                         FacesPartitioning(&my_faces,iomodel);
     692                        EdgesPartitioning(iomodel);
     693                        FacesPartitioning(iomodel);
    702694                        break;
    703695                default:
    … …  
    729721                                for(i=0;i<iomodel->numberofedges;i++){
    730722                                        if(iomodel->edges[i*3+2]==2){
    731                                                 if(my_edges[i]){
     723                                                if(iomodel->my_edges[i]){
    732724                                                        v1 = iomodel->edges[3*i+0]-1;
    733725                                                        v2 = iomodel->edges[3*i+1]-1;
    … …  
    752744                                for(i=0;i<iomodel->numberofedges;i++){
    753745                                        if(iomodel->edges[i*3+2]==2){
    754                                                 if(my_edges[i]){
     746                                                if(iomodel->my_edges[i]){
    755747                                                        v1 = iomodel->edges[3*i+0]-1;
    756748                                                        v2 = iomodel->edges[3*i+1]-1;
    … …  
    780772        xDelete<IssmDouble>(times);
    781773        xDelete<IssmDouble>(values);
    782         xDelete<bool>(my_edges);
    783         xDelete<bool>(my_faces);
    784774        xDelete<bool>(boundaryedge);
    785775}/*}}}*/

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

    r22077 r23167  
    1515        int   numberoffaces,elementnbv;
    1616        int   id0 = iomodel->nodecounter;
    17         bool *my_faces = NULL;
    18         bool *my_edges = NULL;
    1917        bool *my_nodes = NULL;
    2018        Node *node     = NULL;
    … …  
    7068
    7169                case P1xP2Enum:
    72                         EdgesPartitioning(&my_edges,iomodel);
     70                        EdgesPartitioning(iomodel);
    7371                        for(i=0;i<iomodel->numberofvertices;i++){
    7472                                if(iomodel->my_vertices[i]){
    … …  
    8078                        for(i=0;i<iomodel->numberofedges;i++){
    8179                                if(iomodel->edges[i*3+2]==2){
    82                                         if(my_edges[i]){
     80                                        if(iomodel->my_edges[i]){
    8381                                                node = new Node(id0+iomodel->numberofvertices+i+1,counter+1,lid++,0,iomodel,analysis,approximation);
    8482                                                nodes->AddObject(node);
    … …  
    9088
    9189                case P1xP3Enum:
    92                         EdgesPartitioning(&my_edges,iomodel);
     90                        EdgesPartitioning(iomodel);
    9391                        for(i=0;i<iomodel->numberofvertices;i++){
    9492                                if(iomodel->my_vertices[i]){
    … …  
    10098                        for(i=0;i<iomodel->numberofedges;i++){
    10199                                if(iomodel->edges[i*3+2]==2){
    102                                         if(my_edges[i]){
     100                                        if(iomodel->my_edges[i]){
    103101                                                node = new Node(id0+iomodel->numberofvertices+2*i+1,counter+1,lid++,0,iomodel,analysis,approximation);
    104102                                                nodes->AddObject(node);
    … …  
    111109                        break;
    112110                case P1xP4Enum:
    113                         EdgesPartitioning(&my_edges,iomodel);
     111                        EdgesPartitioning(iomodel);
    114112                        for(i=0;i<iomodel->numberofvertices;i++){
    115113                                if(iomodel->my_vertices[i]){
    … …  
    120118                        for(i=0;i<iomodel->numberofedges;i++){
    121119                                if(iomodel->edges[i*3+2]==2){/*Vertical edges*/
    122                                         if(my_edges[i]){
     120                                        if(iomodel->my_edges[i]){
    123121                                                node = new Node(id0+iomodel->numberofvertices+3*i+1,counter+1,lid++,0,iomodel,analysis,approximation);
    124122                                                nodes->AddObject(node);
    … …  
    134132
    135133                case P2xP1Enum:
    136                         EdgesPartitioning(&my_edges,iomodel);
     134                        EdgesPartitioning(iomodel);
    137135                        for(i=0;i<iomodel->numberofvertices;i++){
    138136                                if(iomodel->my_vertices[i]){
    … …  
    144142                        for(i=0;i<iomodel->numberofedges;i++){
    145143                                if(iomodel->edges[i*3+2]!=2){
    146                                         if(my_edges[i]){
     144                                        if(iomodel->my_edges[i]){
    147145                                                node = new Node(id0+iomodel->numberofvertices+i+1,counter+1,lid++,0,iomodel,analysis,approximation);
    148146                                                nodes->AddObject(node);
    … …  
    154152
    155153                case P2Enum:
    156                         EdgesPartitioning(&my_edges,iomodel);
    157                         for(i=0;i<iomodel->numberofvertices;i++){
    158                                 if(iomodel->my_vertices[i]){
    159                                         nodes->AddObject(new Node(id0+i+1,i,lid++,i,iomodel,analysis,approximation));
    160                                 }
    161                         }
    162                         for(i=0;i<iomodel->numberofedges;i++){
    163                                 if(my_edges[i]){
     154                        EdgesPartitioning(iomodel);
     155                        for(i=0;i<iomodel->numberofvertices;i++){
     156                                if(iomodel->my_vertices[i]){
     157                                        nodes->AddObject(new Node(id0+i+1,i,lid++,i,iomodel,analysis,approximation));
     158                                }
     159                        }
     160                        for(i=0;i<iomodel->numberofedges;i++){
     161                                if(iomodel->my_edges[i]){
    164162                                        nodes->AddObject(new Node(id0+iomodel->numberofvertices+i+1,iomodel->numberofvertices+i,lid++,0,iomodel,analysis,approximation));
    165163                                }
    … …  
    167165                        id0 = id0+iomodel->numberofvertices+iomodel->numberofedges;
    168166              if(iomodel->meshelementtype==PentaEnum){
    169                                 FacesPartitioning(&my_faces,iomodel);
     167                                FacesPartitioning(iomodel);
    170168                                for(i=0;i<iomodel->numberoffaces;i++){
    171169                                        if(iomodel->faces[i*iomodel->facescols+2]==2){/*Vertical quads*/
    172                                                 if(my_faces[i]){
     170                                                if(iomodel->my_faces[i]){
    173171                                                        node = new Node(id0+i+1,iomodel->numberofvertices+iomodel->numberofedges+i,lid++,0,iomodel,analysis,approximation);
    174172                                                        nodes->AddObject(node);
    … …  
    185183                        break;
    186184                case P2bubbleEnum:
    187                         EdgesPartitioning(&my_edges,iomodel);
    188                         for(i=0;i<iomodel->numberofvertices;i++){
    189                                 if(iomodel->my_vertices[i]){
    190                                         nodes->AddObject(new Node(id0+i+1,i,lid++,i,iomodel,analysis,approximation));
    191                                 }
    192                         }
    193                         for(i=0;i<iomodel->numberofedges;i++){
    194                                 if(my_edges[i]){
     185                        EdgesPartitioning(iomodel);
     186                        for(i=0;i<iomodel->numberofvertices;i++){
     187                                if(iomodel->my_vertices[i]){
     188                                        nodes->AddObject(new Node(id0+i+1,i,lid++,i,iomodel,analysis,approximation));
     189                                }
     190                        }
     191                        for(i=0;i<iomodel->numberofedges;i++){
     192                                if(iomodel->my_edges[i]){
    195193                                        nodes->AddObject(new Node(id0+iomodel->numberofvertices+i+1,iomodel->numberofvertices+i,lid++,0,iomodel,analysis,approximation));
    196194                                }
    … …  
    198196                        id0 = id0+iomodel->numberofvertices+iomodel->numberofedges;
    199197                        if(iomodel->meshelementtype==PentaEnum){
    200                                 FacesPartitioning(&my_faces,iomodel);
     198                                FacesPartitioning(iomodel);
    201199                                for(i=0;i<iomodel->numberoffaces;i++){
    202200                                        if(iomodel->faces[i*iomodel->facescols+2]==2){/*Vertical quads*/
    203                                                 if(my_faces[i]){
     201                                                if(iomodel->my_faces[i]){
    204202                                                        node = new Node(id0+i+1,iomodel->numberofvertices+iomodel->numberofedges+i,lid++,0,iomodel,analysis,approximation);
    205203                                                        nodes->AddObject(node);
    … …  
    222220                        break;
    223221                case P2xP4Enum:
    224                         EdgesPartitioning(&my_edges,iomodel);
    225                         FacesPartitioning(&my_faces,iomodel);
     222                        EdgesPartitioning(iomodel);
     223                        FacesPartitioning(iomodel);
    226224                        for(i=0;i<iomodel->numberofvertices;i++){
    227225                                if(iomodel->my_vertices[i]){
    … …  
    232230                        for(i=0;i<iomodel->numberofedges;i++){
    233231                                if(iomodel->edges[i*3+2]==2){/*Vertical edges*/
    234                                         if(my_edges[i]){
     232                                        if(iomodel->my_edges[i]){
    235233                                                node = new Node(id0+iomodel->numberofvertices+3*i+1,counter+1,lid++,0,iomodel,analysis,approximation);
    236234                                                nodes->AddObject(node);
    … …  
    243241                                }
    244242                                else if(iomodel->edges[i*3+2]==1){/*Horizontal edges*/
    245                                         if(my_edges[i]){
     243                                        if(iomodel->my_edges[i]){
    246244                                                node = new Node(id0+iomodel->numberofvertices+3*i+1,counter+1,lid++,0,iomodel,analysis,approximation);
    247245                                                nodes->AddObject(node);
    … …  
    256254                        for(i=0;i<iomodel->numberoffaces;i++){
    257255                                if(iomodel->faces[i*iomodel->facescols+2]==2){/*Vertical quads*/
    258                                         if(my_faces[i]){
     256                                        if(iomodel->my_faces[i]){
    259257                                                node = new Node(id0+3*i+1,counter+1,lid++,0,iomodel,analysis,approximation);
    260258                                                nodes->AddObject(node);
    … …  
    356354                        _assert_(approximation==FSApproximationEnum);
    357355                        /*P2 velocity*/
    358                         EdgesPartitioning(&my_edges,iomodel);
    359                         for(i=0;i<iomodel->numberofvertices;i++){
    360                                 if(iomodel->my_vertices[i]){
    361                                         nodes->AddObject(new Node(id0+i+1,i,lid++,i,iomodel,analysis,FSvelocityEnum));
    362                                 }
    363                         }
    364                         for(i=0;i<iomodel->numberofedges;i++){
    365                                 if(my_edges[i]){
     356                        EdgesPartitioning(iomodel);
     357                        for(i=0;i<iomodel->numberofvertices;i++){
     358                                if(iomodel->my_vertices[i]){
     359                                        nodes->AddObject(new Node(id0+i+1,i,lid++,i,iomodel,analysis,FSvelocityEnum));
     360                                }
     361                        }
     362                        for(i=0;i<iomodel->numberofedges;i++){
     363                                if(iomodel->my_edges[i]){
    366364                                        nodes->AddObject(new Node(id0+iomodel->numberofvertices+i+1,iomodel->numberofvertices+i,lid++,0,iomodel,analysis,FSvelocityEnum));
    367365                                }
    … …  
    369367                        id0 = id0+iomodel->numberofvertices+iomodel->numberofedges;
    370368              if(iomodel->meshelementtype==PentaEnum){
    371                                 FacesPartitioning(&my_faces,iomodel);
     369                                FacesPartitioning(iomodel);
    372370                                for(i=0;i<iomodel->numberoffaces;i++){
    373371                                        if(iomodel->faces[i*iomodel->facescols+2]==2){/*Vertical quads*/
    374                                                 if(my_faces[i]){
     372                                                if(iomodel->my_faces[i]){
    375373                                                        node = new Node(id0+i+1,iomodel->numberofvertices+iomodel->numberofedges+i,lid++,0,iomodel,analysis,FSvelocityEnum);
    376374                                                        nodes->AddObject(node);
    … …  
    403401                        _assert_(approximation==FSApproximationEnum);
    404402                        /*P2 velocity*/
    405                         EdgesPartitioning(&my_edges,iomodel);
    406                         for(i=0;i<iomodel->numberofvertices;i++){
    407                                 if(iomodel->my_vertices[i]){
    408                                         nodes->AddObject(new Node(id0+i+1,i,lid++,i,iomodel,analysis,FSvelocityEnum));
    409                                 }
    410                         }
    411                         for(i=0;i<iomodel->numberofedges;i++){
    412                                 if(my_edges[i]){
     403                        EdgesPartitioning(iomodel);
     404                        for(i=0;i<iomodel->numberofvertices;i++){
     405                                if(iomodel->my_vertices[i]){
     406                                        nodes->AddObject(new Node(id0+i+1,i,lid++,i,iomodel,analysis,FSvelocityEnum));
     407                                }
     408                        }
     409                        for(i=0;i<iomodel->numberofedges;i++){
     410                                if(iomodel->my_edges[i]){
    413411                                        nodes->AddObject(new Node(id0+iomodel->numberofvertices+i+1,iomodel->numberofvertices+i,lid++,0,iomodel,analysis,FSvelocityEnum));
    414412                                }
    … …  
    416414                        id0 = id0+iomodel->numberofvertices+iomodel->numberofedges;
    417415              if(iomodel->meshelementtype==PentaEnum){
    418                                 FacesPartitioning(&my_faces,iomodel);
     416                                FacesPartitioning(iomodel);
    419417                                for(i=0;i<iomodel->numberoffaces;i++){
    420418                                        if(iomodel->faces[i*iomodel->facescols+2]==2){/*Vertical quads*/
    421                                                 if(my_faces[i]){
     419                                                if(iomodel->my_faces[i]){
    422420                                                        node = new Node(id0+i+1,iomodel->numberofvertices+iomodel->numberofedges+i,lid++,0,iomodel,analysis,FSvelocityEnum);
    423421                                                        nodes->AddObject(node);
    … …  
    437435                case OneLayerP4zEnum:
    438436                        _assert_(approximation==FSApproximationEnum);
    439                         EdgesPartitioning(&my_edges,iomodel);
    440                         FacesPartitioning(&my_faces,iomodel);
     437                        EdgesPartitioning(iomodel);
     438                        FacesPartitioning(iomodel);
    441439                        /*P2xP4 velocity*/
    442440                        for(i=0;i<iomodel->numberofvertices;i++){
    … …  
    448446                        for(i=0;i<iomodel->numberofedges;i++){
    449447                                if(iomodel->edges[i*3+2]==2){/*Vertical edges*/
    450                                         if(my_edges[i]){
     448                                        if(iomodel->my_edges[i]){
    451449                                                node = new Node(id0+iomodel->numberofvertices+3*i+1,counter+1,lid++,0,iomodel,analysis,FSvelocityEnum);
    452450                                                nodes->AddObject(node);
    … …  
    459457                                }
    460458                                else if(iomodel->edges[i*3+2]==1){/*Horizontal edges*/
    461                                         if(my_edges[i]){
     459                                        if(iomodel->my_edges[i]){
    462460                                                node = new Node(id0+iomodel->numberofvertices+3*i+1,counter+1,lid++,0,iomodel,analysis,FSvelocityEnum);
    463461                                                nodes->AddObject(node);
    … …  
    472470                        for(i=0;i<iomodel->numberoffaces;i++){
    473471                                if(iomodel->faces[i*iomodel->facescols+2]==2){/*Vertical quads*/
    474                                         if(my_faces[i]){
     472                                        if(iomodel->my_faces[i]){
    475473                                                node = new Node(id0+3*i+1,counter+1,lid++,0,iomodel,analysis,FSvelocityEnum);
    476474                                                nodes->AddObject(node);
    … …  
    502500                        _assert_(approximation==FSApproximationEnum);
    503501                        /*P2b velocity*/
    504                         EdgesPartitioning(&my_edges,iomodel);
    505                         for(i=0;i<iomodel->numberofvertices;i++){
    506                                 if(iomodel->my_vertices[i]){
    507                                         nodes->AddObject(new Node(id0+i+1,i,lid++,i,iomodel,analysis,FSvelocityEnum));
    508                                 }
    509                         }
    510                         for(i=0;i<iomodel->numberofedges;i++){
    511                                 if(my_edges[i]){
     502                        EdgesPartitioning(iomodel);
     503                        for(i=0;i<iomodel->numberofvertices;i++){
     504                                if(iomodel->my_vertices[i]){
     505                                        nodes->AddObject(new Node(id0+i+1,i,lid++,i,iomodel,analysis,FSvelocityEnum));
     506                                }
     507                        }
     508                        for(i=0;i<iomodel->numberofedges;i++){
     509                                if(iomodel->my_edges[i]){
    512510                                        nodes->AddObject(new Node(id0+iomodel->numberofvertices+i+1,iomodel->numberofvertices+i,lid++,0,iomodel,analysis,FSvelocityEnum));
    513511                                }
    … …  
    515513                        id0 = id0+iomodel->numberofvertices+iomodel->numberofedges;
    516514                        if(iomodel->meshelementtype==PentaEnum){
    517                                 FacesPartitioning(&my_faces,iomodel);
     515                                FacesPartitioning(iomodel);
    518516                                for(i=0;i<iomodel->numberoffaces;i++){
    519517                                        if(iomodel->faces[i*iomodel->facescols+2]==2){/*Vertical quads*/
    520                                                 if(my_faces[i]){
     518                                                if(iomodel->my_faces[i]){
    521519                                                        node = new Node(id0+i+1,iomodel->numberofvertices+iomodel->numberofedges+i,lid++,0,iomodel,analysis,FSvelocityEnum);
    522520                                                        nodes->AddObject(node);
    … …  
    558556                        _assert_(approximation==FSApproximationEnum);
    559557                        /*P2b velocity*/
    560                         EdgesPartitioning(&my_edges,iomodel);
    561                         for(i=0;i<iomodel->numberofvertices;i++){
    562                                 if(iomodel->my_vertices[i]){
    563                                         nodes->AddObject(new Node(id0+i+1,i,lid++,i,iomodel,analysis,FSvelocityEnum));
    564                                 }
    565                         }
    566                         for(i=0;i<iomodel->numberofedges;i++){
    567                                 if(my_edges[i]){
     558                        EdgesPartitioning(iomodel);
     559                        for(i=0;i<iomodel->numberofvertices;i++){
     560                                if(iomodel->my_vertices[i]){
     561                                        nodes->AddObject(new Node(id0+i+1,i,lid++,i,iomodel,analysis,FSvelocityEnum));
     562                                }
     563                        }
     564                        for(i=0;i<iomodel->numberofedges;i++){
     565                                if(iomodel->my_edges[i]){
    568566                                        nodes->AddObject(new Node(id0+iomodel->numberofvertices+i+1,iomodel->numberofvertices+i,lid++,0,iomodel,analysis,FSvelocityEnum));
    569567                                }
    … …  
    571569                        id0 = id0+iomodel->numberofvertices+iomodel->numberofedges;
    572570                        if(iomodel->meshelementtype==PentaEnum){
    573                                 FacesPartitioning(&my_faces,iomodel);
     571                                FacesPartitioning(iomodel);
    574572                                for(i=0;i<iomodel->numberoffaces;i++){
    575573                                        if(iomodel->faces[i*iomodel->facescols+2]==2){/*Vertical quads*/
    576                                                 if(my_faces[i]){
     574                                                if(iomodel->my_faces[i]){
    577575                                                        node = new Node(id0+i+1,iomodel->numberofvertices+iomodel->numberofedges+i,lid++,0,iomodel,analysis,FSvelocityEnum);
    578576                                                        nodes->AddObject(node);
    … …  
    602600
    603601        /*Clean up*/
    604         xDelete<bool>(my_faces);
    605         xDelete<bool>(my_edges);
    606602        xDelete<bool>(my_nodes);
    607603}

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

    r17692 r23167  
    88#include "./ModelProcessorx.h"
    99
    10 void EdgesPartitioning(bool** pmy_edges,IoModel* iomodel){
     10void EdgesPartitioning(IoModel* iomodel){
    1111
    12         /*Intermediaries*/
    13         int elementnbe;
     12        /*If faces are already present, exit*/
     13        if(iomodel->my_edges) return;
    1414
    1515        /*Get edges and elements*/
    … …  
    1818
    1919        /*Mesh dependent variables*/
     20        int elementnbe;
    2021        switch(iomodel->meshelementtype){
    2122                case TriaEnum:  elementnbe = 3; break;
    … …  
    2627
    2728        /*output: */
    28         bool* my_edges=xNewZeroInit<bool>(iomodel->numberofedges);
     29        iomodel->my_edges=xNewZeroInit<bool>(iomodel->numberofedges);
    2930
    3031        for(int i=0;i<iomodel->numberofelements;i++){
    3132                if(iomodel->my_elements[i]){
    3233                        for(int j=0;j<elementnbe;j++){
    33                                 my_edges[iomodel->elementtoedgeconnectivity[i*elementnbe+j]] = true;
     34                                iomodel->my_edges[iomodel->elementtoedgeconnectivity[i*elementnbe+j]] = true;
    3435                        }
    3536                }
    3637        }
    37 
    38         /*Free data and assign output pointers */
    39         *pmy_edges=my_edges;
    4038}

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

    r17700 r23167  
    88#include "./ModelProcessorx.h"
    99
    10 void FacesPartitioning(bool** pmy_faces,IoModel* iomodel){
     10void FacesPartitioning(IoModel* iomodel){
    1111
    12         /*Intermediaries*/
    13         int elementnbf;
     12        /*If faces are already present, exit*/
     13        if(iomodel->my_faces) return;
    1414
    1515        /*Get faces and elements*/
    … …  
    1818
    1919        /*Mesh dependent variables*/
     20        int elementnbf;
    2021        if(iomodel->domaintype==Domain2DhorizontalEnum){
    2122                elementnbf = 3;
    … …  
    3132        }
    3233        /*output: */
    33         bool* my_faces=xNewZeroInit<bool>(iomodel->numberoffaces);
     34        iomodel->my_faces=xNewZeroInit<bool>(iomodel->numberoffaces);
    3435
    3536        for(int i=0;i<iomodel->numberofelements;i++){
    … …  
    3839                                _assert_(iomodel->elementtofaceconnectivity[i*elementnbf+j] >= 0);
    3940                                _assert_(iomodel->elementtofaceconnectivity[i*elementnbf+j] <  iomodel->numberoffaces);
    40                                 my_faces[iomodel->elementtofaceconnectivity[i*elementnbf+j]] = true;
     41                                iomodel->my_faces[iomodel->elementtofaceconnectivity[i*elementnbf+j]] = true;
    4142                        }
    4243                }
    4344        }
    44 
    45         /*Free data and assign output pointers */
    46         *pmy_faces=my_faces;
    4745}

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

    r22739 r23167  
    2626void ElementsAndVerticesPartitioning(bool** pmy_elements, int** pmy_vertices, IoModel* iomodel);
    2727void NodesPartitioning(bool** pmy_nodes,bool* my_elements, int* my_vertices,  IoModel* iomodel, bool continuous);
    28 void FacesPartitioning(bool** pmy_faces,IoModel* iomodel);
    29 void EdgesPartitioning(bool** pmy_edges,IoModel* iomodel);
     28void FacesPartitioning(IoModel* iomodel);
     29void EdgesPartitioning(IoModel* iomodel);
    3030
    3131/*Mesh properties*/

  • issm/trunk-jpl/src/c/solutionsequences/convergence.cpp

    r18619 r23167  
    3737        if (VerboseConvergence()){
    3838
    39                 //compute KUF = KU - F = K*U - F
     39                /*compute KUF = KU - F = K*U - F*/
    4040                KU=uf->Duplicate(); Kff->MatMult(uf,KU);
    4141                KUF=KU->Duplicate(); KU->Copy(KUF); KUF->AYPX(pf,-1.0);
    4242
    43                 //compute norm(KUF), norm(F) and residue
     43                /*compute norm(KUF), norm(F) and residue*/
    4444                nKUF=KUF->Norm(NORM_TWO);
    4545                nF=pf->Norm(NORM_TWO);
    4646                solver_residue=nKUF/nF;
    4747                _printf0_("\n" << "   solver residue: norm(KU-F)/norm(F)=" << solver_residue << "\n");
     48                if(xIsNan<IssmDouble>(solver_residue)){
     49                        //Kff->Echo();
     50                }
    4851
    49                 //clean up
     52                /*clean up*/
    5053                delete KU;
    5154                delete KUF;
    … …  
    5457        /*Force equilibrium (Mandatory)*/
    5558
    56         //compute K[n]U[n-1]F = K[n]U[n-1] - F
     59        /*compute K[n]U[n-1]F = K[n]U[n-1] - F*/
    5760        _assert_(uf); _assert_(Kff);
    5861        KUold=uf->Duplicate(); Kff->MatMult(old_uf,KUold);
Note: See TracChangeset for help on using the changeset viewer.