/[escript]/branches/trilinos_from_5897/dudley/src/IndexList.cpp
ViewVC logotype

Diff of /branches/trilinos_from_5897/dudley/src/IndexList.cpp

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 6008 by caltinay, Fri Feb 5 03:37:49 2016 UTC revision 6009 by caltinay, Wed Mar 2 04:13:26 2016 UTC
# Line 14  Line 14 
14  *  *
15  *****************************************************************************/  *****************************************************************************/
16    
17  /************************************************************************************/  /****************************************************************************/
18    
19  /* Dudley: Converting an element list into a matrix shape     */  /* Dudley: Converting an element list into a matrix shape     */
20    
21  /************************************************************************************/  /****************************************************************************/
   
 #define ESNEEDPYTHON  
 #include "esysUtils/first.h"  
22    
23  #include "IndexList.h"  #include "IndexList.h"
24    
25    namespace dudley {
26    
27  /* Translate from distributed/local array indices to global indices */  /* Translate from distributed/local array indices to global indices */
28    
 /************************************************************************************/  
29  /* inserts the contributions from the element matrices of elements  /* inserts the contributions from the element matrices of elements
30     into the row index col. If symmetric is set, only the upper     into the row index col. If symmetric is set, only the upper
31     triangle of the matrix is stored. */     triangle of the matrix is stored. */
   
32  void Dudley_IndexList_insertElements(IndexList* index_list,  void Dudley_IndexList_insertElements(IndexList* index_list,
33                                       Dudley_ElementFile * elements,                                       Dudley_ElementFile * elements,
34                                       bool reduce_row_order, index_t* row_map,                                       bool reduce_row_order, index_t* row_map,
# Line 40  void Dudley_IndexList_insertElements(Ind Line 37  void Dudley_IndexList_insertElements(Ind
37      /* index_list is an array of linked lists. Each entry is a row (DOF) and contains the indices to the non-zero columns */      /* index_list is an array of linked lists. Each entry is a row (DOF) and contains the indices to the non-zero columns */
38      index_t color;      index_t color;
39      dim_t e, kr, kc, NN_row, NN_col, icol, irow, NN;      dim_t e, kr, kc, NN_row, NN_col, icol, irow, NN;
40      if (elements != NULL)      if (elements != NULL) {
41      {          NN = elements->numNodes;
42      NN = elements->numNodes;          NN_col = (elements->numShapes);
43      NN_col = (elements->numShapes);          NN_row = (elements->numShapes);
     NN_row = (elements->numShapes);  
44    
45      for (color = elements->minColor; color <= elements->maxColor; color++)          for (color = elements->minColor; color <= elements->maxColor; color++) {
     {  
46  #pragma omp for private(e,irow,kr,kc,icol) schedule(static)  #pragma omp for private(e,irow,kr,kc,icol) schedule(static)
47          for (e = 0; e < elements->numElements; e++)              for (e = 0; e < elements->numElements; e++) {
48          {                  if (elements->Color[e] == color) {
49          if (elements->Color[e] == color)                      for (kr = 0; kr < NN_row; kr++) {
50          {                          irow = row_map[elements->Nodes[INDEX2(kr, e, NN)]];
51              for (kr = 0; kr < NN_row; kr++)                          for (kc = 0; kc < NN_col; kc++) {
52              {                              icol = col_map[elements->Nodes[INDEX2(kc, e, NN)]];
53              irow = row_map[elements->Nodes[INDEX2(kr, e, NN)]];                              index_list[irow].insertIndex(icol);
54              for (kc = 0; kc < NN_col; kc++)                          }
55              {                      }
56                  icol = col_map[elements->Nodes[INDEX2(kc, e, NN)]];                  }
                 index_list[irow].insertIndex(icol);  
             }  
57              }              }
58          }          }
         }  
     }  
59      }      }
60  }  }
61    
# Line 72  void Dudley_IndexList_insertElementsWith Line 63  void Dudley_IndexList_insertElementsWith
63          index_t firstRow, index_t lastRow, Dudley_ElementFile* elements,          index_t firstRow, index_t lastRow, Dudley_ElementFile* elements,
64          index_t* row_map, index_t* col_map)          index_t* row_map, index_t* col_map)
65  {  {
 /* this does not resolve macro elements */  
66      index_t color;      index_t color;
67      dim_t e, kr, kc, icol, irow, NN;      dim_t e, kr, kc, icol, irow, NN;
68      if (elements != NULL)      if (elements != NULL) {
69      {          NN = elements->numNodes;
70      NN = elements->numNodes;          for (color = elements->minColor; color <= elements->maxColor; color++) {
     for (color = elements->minColor; color <= elements->maxColor; color++)  
     {  
71  #pragma omp for private(e,irow,kr,kc,icol) schedule(static)  #pragma omp for private(e,irow,kr,kc,icol) schedule(static)
72          for (e = 0; e < elements->numElements; e++)              for (e = 0; e < elements->numElements; e++) {
73          {                  if (elements->Color[e] == color) {
74          if (elements->Color[e] == color)                      for (kr = 0; kr < NN; kr++) {
75          {                          irow = row_map[elements->Nodes[INDEX2(kr, e, NN)]];
76              for (kr = 0; kr < NN; kr++)                          if ((firstRow <= irow) && (irow < lastRow)) {
77              {                              irow -= firstRow;
78              irow = row_map[elements->Nodes[INDEX2(kr, e, NN)]];                              for (kc = 0; kc < NN; kc++) {
79              if ((firstRow <= irow) && (irow < lastRow))                                  icol = col_map[elements->Nodes[INDEX2(kc, e, NN)]];
80              {                                  index_list[irow].insertIndex(icol);
81                  irow -= firstRow;                              }
82                  for (kc = 0; kc < NN; kc++)                          }
83                  {                      }
                 icol = col_map[elements->Nodes[INDEX2(kc, e, NN)]];  
                 index_list[irow].insertIndex(icol);  
84                  }                  }
85              }              }
             }  
         }  
86          }          }
87      }      }
     }  
88  }  }
89    
90  void Dudley_IndexList_insertElementsWithRowRangeNoMainDiagonal(  void Dudley_IndexList_insertElementsWithRowRangeNoMainDiagonal(
91          IndexList* index_list, index_t firstRow, index_t lastRow,          IndexList* index_list, index_t firstRow, index_t lastRow,
92          Dudley_ElementFile* elements, index_t* row_map, index_t* col_map)          Dudley_ElementFile* elements, index_t* row_map, index_t* col_map)
93  {  {
     /* this does not resolve macro elements */  
94      index_t color;      index_t color;
95      dim_t e, kr, kc, icol, irow, NN, irow_loc;      dim_t e, kr, kc, icol, irow, NN, irow_loc;
96      if (elements != NULL)      if (elements != NULL) {
97      {          NN = elements->numNodes;
98      NN = elements->numNodes;          for (color = elements->minColor; color <= elements->maxColor; color++) {
     for (color = elements->minColor; color <= elements->maxColor; color++)  
     {  
99  #pragma omp for private(e,irow,kr,kc,icol,irow_loc) schedule(static)  #pragma omp for private(e,irow,kr,kc,icol,irow_loc) schedule(static)
100          for (e = 0; e < elements->numElements; e++)              for (e = 0; e < elements->numElements; e++) {
101          {                  if (elements->Color[e] == color) {
102          if (elements->Color[e] == color)                      for (kr = 0; kr < NN; kr++) {
103          {                          irow = row_map[elements->Nodes[INDEX2(kr, e, NN)]];
104              for (kr = 0; kr < NN; kr++)                          if ((firstRow <= irow) && (irow < lastRow)) {
105              {                              irow_loc = irow - firstRow;
106              irow = row_map[elements->Nodes[INDEX2(kr, e, NN)]];                              for (kc = 0; kc < NN; kc++) {
107              if ((firstRow <= irow) && (irow < lastRow))                                  icol = col_map[elements->Nodes[INDEX2(kc, e, NN)]];
108              {                                  if (icol != irow)
109                  irow_loc = irow - firstRow;                                      index_list[irow_loc].insertIndex(icol);
110                  for (kc = 0; kc < NN; kc++)                              }
111                  {                          }
112                  icol = col_map[elements->Nodes[INDEX2(kc, e, NN)]];                      }
                 if (icol != irow)  
                     index_list[irow_loc].insertIndex(icol);  
113                  }                  }
114              }              }
             }  
115          }          }
         }  
     }  
116      }      }
117  }  }
118    
119    } // namespace dudley
120    

Legend:
Removed from v.6008  
changed lines
  Added in v.6009

  ViewVC Help
Powered by ViewVC 1.1.26