Context Navigation

-              r15396
+              r16137
 void  NodesPartitioning(bool** pmy_nodes,bool* my_elements, int* my_vertices, IoModel* iomodel, bool continuous){
-        /*First thing, this is a new partition for a new analysis_type, therefore, to avoid a leak, erase the nodes partition that might come through pmy_nodes: */
-        xDelete<bool>(*pmy_nodes);
-        /*Now, depending on whether we are running galerkin discontinous or continuous elements, carry out a different partition of the nodes: */
         if(continuous==true)
                 ContinuousGalerkinNodesPartitioning(pmy_nodes,my_elements, my_vertices, iomodel);
 …
 void  ContinuousGalerkinNodesPartitioning(bool** pmy_nodes,bool* my_elements, int* my_vertices, IoModel* iomodel){
-        /*as many nodes as there are vertices */
-        int    numberofvertices;
         /*output: */
+        bool* my_nodes=NULL;
+        /*Fetch parameters: */
+        iomodel->Constant(&numberofvertices,MeshNumberofverticesEnum);
+        my_nodes=xNew<bool>(numberofvertices);
+        for(int i=0;i<numberofvertices;i++) my_nodes[i]=(bool)my_vertices[i];
+        bool* my_nodes=xNew<bool>(iomodel->numberofvertices);
+        for(int i=0;i<iomodel->numberofvertices;i++) my_nodes[i]=(bool)my_vertices[i];
         /*Assign output pointers:*/
 …
 void  DiscontinuousGalerkinNodesPartitioning(bool** pmy_nodes,bool* my_elements, int* my_vertices, IoModel* iomodel){
+        int    numberofelements;
+        /* Each element has it own nodes (as many as vertices) + additional nodes
+         * from neighboring elements for each face. This yields to a very different
+         * partition for the nodes and the vertices. The vertices are similar to
+         * continuous galerkin, but the nodes partitioning involves faces, which
+         * messes up sorting of ids. */
+        /*Fetch parameters: */
+        iomodel->Constant(&numberofelements,MeshNumberofelementsEnum);
+        /*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
+         * the nodes and the vertices. The vertices are similar to continuous galerkin, but the nodes partitioning involves edges, which mess up sorting of
+         * ids. */
+        int i,j;
+        int    dim;
+        /*output: */
+        bool*   my_nodes=NULL;
+        int  i1,i2;
+        /*Intermediaries*/
+        int  i,i1,i2;
         int  cols;
         int  e1,e2;
         int  pos;
-        int  numberofedges;
-        int *edges         = NULL;
-        int *elements      = NULL;
         /*Fetch parameters: */
         iomodel->Constant(&dim,MeshDimensionEnum);
+        /*Get faces and elements*/
+        CreateEdges(iomodel);
         /*Build discontinuous node partitioning
          *  - there are three nodes per element (discontinous)
          *  - for each element present of each partition, its three nodes will be in this partition
          *  - the edges require the dofs of the 2 nodes of each elements sharing the edge.
          *    if the 2 elements sharing the edge are on 2 different cpus, we must duplicate
          *    the two nodes that are not on the cpus so that the edge can access the dofs of
+         *  - the faces require the dofs of the 2 nodes of each elements sharing the face.
+         *    if the 2 elements sharing the face are on 2 different cpus, we must duplicate
+         *    the two nodes that are not on the cpus so that the face can access the dofs of
          *    all its 4 nodes
          */
         /*Allocate*/
         my_nodes=xNewZeroInit<bool>(3*numberofelements);
+        bool* my_nodes=xNewZeroInit<bool>(3*iomodel->numberofelements);
         /*First: add all the nodes of all the elements belonging to this cpu*/
         if (dim==2){
                 for (i=0;i<numberofelements;i++){
+        if(iomodel->dim==2){
+                for (i=0;i<iomodel->numberofelements;i++){
                         if (my_elements[i]){
                                 my_nodes[3*i+0]=true;
 …
         /*Second: add all missing nodes*/
+        /*Get edges and elements*/
+        iomodel->FetchData(&edges,&numberofedges,&cols,MeshEdgesEnum);
+        iomodel->FetchData(&elements,NULL,NULL,MeshElementsEnum);
+        if (cols!=4) _error_("field edges should have 4 columns");
+        /*Get faces and elements*/
+        CreateFaces(iomodel);
         /*!All elements have been partitioned above, only create elements for this CPU: */
         for (i=0;i<numberofedges;i++){
+        for(int i=0;i<iomodel->numberoffaces;i++){
                 /*Get left and right elements*/
                 e1=edges[4*i+2]-1; //edges are [node1 node2 elem1 elem2]
                 e2=edges[4*i+3]-1; //edges are [node1 node2 elem1 elem2]
+                e1=iomodel->faces[4*i+2]-1; //faces are [node1 node2 elem1 elem2]
+                e2=iomodel->faces[4*i+3]-1; //faces are [node1 node2 elem1 elem2]
                 /* 1) If the element e1 is in the current partition
                  * 2) and if the edge of the element is shared by another element (internal edge)
+                 * 2) and if the face of the element is shared by another element (internal face)
                  * 3) and if this element is not in the same partition:
                  * we must clone the nodes on this partition so that the loads (Numericalflux)
 …
                         /*1: Get vertices ids*/
                         i1=edges[4*i+0];
                         i2=edges[4*i+1];
+                        i1=iomodel->faces[4*i+0];
+                        i2=iomodel->faces[4*i+1];
                         /*2: Get the column where these ids are located in the index*/
                         pos=UNDEF;
                         for(j=0;j<3;j++){
                                 if (elements[3*e2+j]==i1) pos=j;
+                        for(int j=0;j<3;j++){
+                                if(iomodel->elements[3*e2+j]==i1) pos=j;
+                        }
                         /*3: We have the id of the elements and the position of the vertices in the index
                          * we can now create the corresponding nodes:*/
                         if (pos==0){
+                        if(pos==0){
                                 my_nodes[e2*3+0]=true;
                                 my_nodes[e2*3+2]=true;
 …
                                 my_nodes[e2*3+0]=true;
+                        }
                         else if (pos==2){
+                        else if(pos==2){
                                 my_nodes[e2*3+2]=true;
                                 my_nodes[e2*3+1]=true;
+                        }
                         else{
                                 _error_("Problem in edges creation");
+                                _error_("Problem in faces creation");
+                        }
+                }
+        }
+        /*Free data: */
+        xDelete<int>(elements);
+        xDelete<int>(edges);
+        /*Assign output pointers:*/
+        /*Free data and assign output pointers */
         *pmy_nodes=my_nodes;
+}

Note: See TracChangeset for help on using the changeset viewer.

Context Navigation

Changeset 16137 for issm/trunk/src/c/modules/ModelProcessorx/NodesPartitioning.cpp

Legend:

issm/trunk

issm/trunk/src

issm/trunk/src/c

issm/trunk/src/c/modules/ModelProcessorx

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

Download in other formats: