/[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 6078 by caltinay, Wed Mar 2 04:13:26 2016 UTC revision 6079 by caltinay, Mon Mar 21 12:22:38 2016 UTC
# Line 21  Line 21 
21  /****************************************************************************/  /****************************************************************************/
22    
23  #include "IndexList.h"  #include "IndexList.h"
24    #include "ElementFile.h"
25    
26  namespace dudley {  namespace dudley {
27    
28  /* Translate from distributed/local array indices to global indices */  /* Translate from distributed/local array indices to global indices */
29    
30  /* inserts the contributions from the element matrices of elements  /// inserts the contributions from the element matrices of elements
31     into the row index col. If symmetric is set, only the upper  /// into the row index col.
32     triangle of the matrix is stored. */  void IndexList_insertElements(IndexList* index_list,
33  void Dudley_IndexList_insertElements(IndexList* index_list,                                const ElementFile* elements, const index_t* map)
                                      Dudley_ElementFile * elements,  
                                      bool reduce_row_order, index_t* row_map,  
                                      bool reduce_col_order, index_t* col_map)  
34  {  {
35      /* 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
36      index_t color;      // contains the indices to the non-zero columns
37      dim_t e, kr, kc, NN_row, NN_col, icol, irow, NN;      if (!elements)
38      if (elements != NULL) {          return;
39          NN = elements->numNodes;  
40          NN_col = (elements->numShapes);      const int NN = elements->numNodes;
41          NN_row = (elements->numShapes);      // number of element nodes for both column and row
42        const int NN_rowcol = elements->numShapes;
43          for (color = elements->minColor; color <= elements->maxColor; color++) {  
44  #pragma omp for private(e,irow,kr,kc,icol) schedule(static)      for (index_t color = elements->minColor; color <= elements->maxColor; color++) {
45              for (e = 0; e < elements->numElements; e++) {  #pragma omp for
46                  if (elements->Color[e] == color) {          for (index_t e = 0; e < elements->numElements; e++) {
47                      for (kr = 0; kr < NN_row; kr++) {              if (elements->Color[e] == color) {
48                          irow = row_map[elements->Nodes[INDEX2(kr, e, NN)]];                  for (int kr = 0; kr < NN_rowcol; kr++) {
49                          for (kc = 0; kc < NN_col; kc++) {                      const index_t irow = map[elements->Nodes[INDEX2(kr, e, NN)]];
50                              icol = col_map[elements->Nodes[INDEX2(kc, e, NN)]];                      for (int kc = 0; kc < NN_rowcol; kc++) {
51                              index_list[irow].insertIndex(icol);                          const index_t icol = map[elements->Nodes[INDEX2(kc, e, NN)]];
52                          }                          index_list[irow].insertIndex(icol);
53                      }                      }
54                  }                  }
55              }              }
# Line 59  void Dudley_IndexList_insertElements(Ind Line 57  void Dudley_IndexList_insertElements(Ind
57      }      }
58  }  }
59    
60  void Dudley_IndexList_insertElementsWithRowRange(IndexList* index_list,  void IndexList_insertElementsWithRowRangeNoMainDiagonal(IndexList* indexList,
61          index_t firstRow, index_t lastRow, Dudley_ElementFile* elements,                                index_t firstRow, index_t lastRow,
62          index_t* row_map, index_t* col_map)                                const ElementFile* elements, const index_t* map)
63  {  {
64      index_t color;      if (!elements)
65      dim_t e, kr, kc, icol, irow, NN;          return;
     if (elements != NULL) {  
         NN = elements->numNodes;  
         for (color = elements->minColor; color <= elements->maxColor; color++) {  
 #pragma omp for private(e,irow,kr,kc,icol) schedule(static)  
             for (e = 0; e < elements->numElements; e++) {  
                 if (elements->Color[e] == color) {  
                     for (kr = 0; kr < NN; kr++) {  
                         irow = row_map[elements->Nodes[INDEX2(kr, e, NN)]];  
                         if ((firstRow <= irow) && (irow < lastRow)) {  
                             irow -= firstRow;  
                             for (kc = 0; kc < NN; kc++) {  
                                 icol = col_map[elements->Nodes[INDEX2(kc, e, NN)]];  
                                 index_list[irow].insertIndex(icol);  
                             }  
                         }  
                     }  
                 }  
             }  
         }  
     }  
 }  
66    
67  void Dudley_IndexList_insertElementsWithRowRangeNoMainDiagonal(      const int NN = elements->numNodes;
68          IndexList* index_list, index_t firstRow, index_t lastRow,      for (index_t color = elements->minColor; color <= elements->maxColor; color++) {
69          Dudley_ElementFile* elements, index_t* row_map, index_t* col_map)  #pragma omp for
70  {          for (index_t e = 0; e < elements->numElements; e++) {
71      index_t color;              if (elements->Color[e] == color) {
72      dim_t e, kr, kc, icol, irow, NN, irow_loc;                  for (int kr = 0; kr < NN; kr++) {
73      if (elements != NULL) {                      const index_t irow = map[elements->Nodes[INDEX2(kr, e, NN)]];
74          NN = elements->numNodes;                      if (firstRow <= irow && irow < lastRow) {
75          for (color = elements->minColor; color <= elements->maxColor; color++) {                          const index_t irow_loc = irow - firstRow;
76  #pragma omp for private(e,irow,kr,kc,icol,irow_loc) schedule(static)                          for (int kc = 0; kc < NN; kc++) {
77              for (e = 0; e < elements->numElements; e++) {                              const index_t icol = map[elements->Nodes[INDEX2(kc, e, NN)]];
78                  if (elements->Color[e] == color) {                              if (icol != irow)
79                      for (kr = 0; kr < NN; kr++) {                                  indexList[irow_loc].insertIndex(icol);
                         irow = row_map[elements->Nodes[INDEX2(kr, e, NN)]];  
                         if ((firstRow <= irow) && (irow < lastRow)) {  
                             irow_loc = irow - firstRow;  
                             for (kc = 0; kc < NN; kc++) {  
                                 icol = col_map[elements->Nodes[INDEX2(kc, e, NN)]];  
                                 if (icol != irow)  
                                     index_list[irow_loc].insertIndex(icol);  
                             }  
80                          }                          }
81                      }                      }
82                  }                  }

Legend:
Removed from v.6078  
changed lines
  Added in v.6079

  ViewVC Help
Powered by ViewVC 1.1.26