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

Diff of /branches/trilinos_from_5897/dudley/src/ElementFile_createColoring.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 14  Line 14 
14  *  *
15  *****************************************************************************/  *****************************************************************************/
16    
 /****************************************************************************/  
 /*                                                                                                         */  
 /*   Dudley: ElementFile                                                                                   */  
 /*                                                                                                         */  
 /*   This routine tries to reduce the number of colors used to color elements in the Dudley_ElementFile in */  
 /*                                                                                                         */  
 /****************************************************************************/  
   
17  #include "ElementFile.h"  #include "ElementFile.h"
18  #include "Util.h"  #include "Util.h"
19    
20  namespace dudley {  namespace dudley {
21    
22  void Dudley_ElementFile_createColoring(Dudley_ElementFile* in, dim_t numNodes, index_t* degreeOfFreedom)  void ElementFile::createColoring(dim_t nNodes, const index_t* degreeOfFreedom)
23  {  {
24      dim_t e, i, numUncoloredElements, n, len, NN;      if (numElements < 1)
     index_t *maskDOF, min_id, max_id;  
     bool independent;  
   
     if (in == NULL)  
         return;  
     if (in->numElements < 1)  
25          return;          return;
     NN = in->numNodes;  
26    
27      min_id = Dudley_Util_getMinInt(1, numNodes, degreeOfFreedom);      //const std::pair<index_t,index_t> idRange(util::getMinMaxInt(
28      max_id = Dudley_Util_getMaxInt(1, numNodes, degreeOfFreedom);      //                                        1, dofMap.size(), &dofMap[0]));
29      len = max_id - min_id + 1;      const std::pair<index_t,index_t> idRange(util::getMinMaxInt(
30      maskDOF = new index_t[len];                                              1, nNodes, degreeOfFreedom));
31  #pragma omp parallel for private(e) schedule(static)  
32      for (e = 0; e < in->numElements; e++)      const dim_t NN = numNodes;
33          in->Color[e] = -1;      index_t min_id = idRange.first;
34      numUncoloredElements = in->numElements;      index_t max_id = idRange.second;
35      in->minColor = 0;      dim_t len = max_id - min_id + 1;
36      in->maxColor = in->minColor - 1;      index_t* maskDOF = new index_t[len];
37      while (numUncoloredElements > 0)  #pragma omp parallel for
38      {      for (index_t e = 0; e < numElements; e++)
39          /* initialize the mask marking nodes used by a color */          Color[e] = -1;
40  #pragma omp parallel for private(n) schedule(static)      dim_t numUncoloredElements = numElements;
41          for (n = 0; n < len; n++)      minColor = 0;
42        maxColor = minColor - 1;
43        while (numUncoloredElements > 0) {
44            // initialize the mask marking nodes used by a color
45    #pragma omp parallel for
46            for (index_t n = 0; n < len; n++)
47              maskDOF[n] = -1;              maskDOF[n] = -1;
48          numUncoloredElements = 0;          numUncoloredElements = 0;
49          /* OMP ? */          for (index_t e = 0; e < numElements; e++) {
50          for (e = 0; e < in->numElements; e++)              if (Color[e] < 0) {
51          {                  // find out if element e is independent from the elements
52              if (in->Color[e] < 0)                  // already colored:
53              {                  bool independent = true;
54                  /* find out if element e is independent from the elements already colored: */                  for (int i = 0; i < NN; i++) {
                 independent = true;  
                 for (i = 0; i < NN; i++)  
                 {  
55  #ifdef BOUNDS_CHECK  #ifdef BOUNDS_CHECK
56                      if (in->Nodes[INDEX2(i, e, NN)] < 0 || in->Nodes[INDEX2(i, e, NN)] >= numNodes)                      if (Nodes[INDEX2(i, e, NN)] < 0 || Nodes[INDEX2(i, e, NN)] >= nNodes)
57                      {                      {
58                          printf("BOUNDS_CHECK %s %d i=%d e=%d NN=%d min_id=%d in->Nodes[INDEX2...]=%d\n", __FILE__,                          printf("BOUNDS_CHECK %s %d i=%d e=%d NN=%d min_id=%d Nodes[INDEX2...]=%d\n", __FILE__,
59                                 __LINE__, i, e, NN, min_id, in->Nodes[INDEX2(i, e, NN)]);                                 __LINE__, i, e, NN, min_id, Nodes[INDEX2(i, e, NN)]);
60                          exit(1);                          exit(1);
61                      }                      }
62                      if ((degreeOfFreedom[in->Nodes[INDEX2(i, e, NN)]] - min_id) >= len                      if ((degreeOfFreedom[Nodes[INDEX2(i, e, NN)]] - min_id) >= len
63                          || (degreeOfFreedom[in->Nodes[INDEX2(i, e, NN)]] - min_id) < 0)                          || (degreeOfFreedom[Nodes[INDEX2(i, e, NN)]] - min_id) < 0)
64                      {                      {
65                          printf("BOUNDS_CHECK %s %d i=%d e=%d NN=%d min_id=%d dof=%d\n", __FILE__, __LINE__, i, e,                          printf("BOUNDS_CHECK %s %d i=%d e=%d NN=%d min_id=%d dof=%d\n", __FILE__, __LINE__, i, e,
66                                 NN, min_id, degreeOfFreedom[in->Nodes[INDEX2(i, e, NN)]] - min_id);                                 NN, min_id, degreeOfFreedom[Nodes[INDEX2(i, e, NN)]] - min_id);
67                          exit(1);                          exit(1);
68                      }                      }
69  #endif  #endif
70                      if (maskDOF[degreeOfFreedom[in->Nodes[INDEX2(i, e, NN)]] - min_id] > 0)                      if (maskDOF[degreeOfFreedom[Nodes[INDEX2(i, e, NN)]] - min_id] > 0)
71                      {                      {
72                          independent = false;                          independent = false;
73                          break;                          break;
74                      }                      }
75                  }                  }
76                  /* if e is independent a new color is assigned and the nodes are marked as being used */                  // if e is independent a new color is assigned and the nodes
77                  if (independent)                  // are marked as being used
78                  {                  if (independent) {
79                      for (i = 0; i < NN; i++)                      for (int i = 0; i < NN; i++)
80                          maskDOF[degreeOfFreedom[in->Nodes[INDEX2(i, e, NN)]] - min_id] = 1;                          maskDOF[degreeOfFreedom[Nodes[INDEX2(i, e, NN)]] - min_id] = 1;
81                      in->Color[e] = in->maxColor + 1;                      Color[e] = maxColor + 1;
82                  }                  } else {
                 else  
                 {  
83                      numUncoloredElements++;                      numUncoloredElements++;
84                  }                  }
85              }              }
86            } // for all elements
87          }          maxColor++;
88          in->maxColor++;      } // end of while loop
     }                       /* end of while loop */  
     /* all done : */  
89      delete[] maskDOF;      delete[] maskDOF;
90  }  }
91    

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

  ViewVC Help
Powered by ViewVC 1.1.26