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

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

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

revision 6089 by caltinay, Tue Mar 22 06:58:00 2016 UTC revision 6090 by caltinay, Wed Mar 23 06:35:54 2016 UTC
# Line 26  using esys_trilinos::TrilinosMatrixAdapt Line 26  using esys_trilinos::TrilinosMatrixAdapt
26    
27  namespace dudley {  namespace dudley {
28    
29  static void Assemble_addToSystemMatrix_Paso(paso::SystemMatrix* S,  static void addToSystemMatrixPasoCSC(paso::SystemMatrix* S,
30                          int NN_Equa, const index_t* Nodes_Equa, int num_Equa,                                       const std::vector<index_t>& Nodes,
31                          int NN_Sol, const index_t* Nodes_Sol, int num_Sol,                                       int numEq,
32                          const double* array);                                       const std::vector<double>& array);
33    
34  #if USE_TRILINOS  static void addToSystemMatrixPasoCSR(paso::SystemMatrix* S,
35  static void Assemble_addToSystemMatrix_Trilinos(TrilinosMatrixAdapter* S,                                       const std::vector<index_t>& Nodes,
36                          int NN_Equa, const index_t* Nodes_Equa, int num_Equa,                                       int numEq,
37                          int NN_Sol, const index_t* Nodes_Sol, int num_Sol,                                       const std::vector<double>& array);
38                          const double* array);  
39  #endif  void Assemble_addToSystemMatrix(escript::ASM_ptr S,
40                                    const std::vector<index_t>& Nodes, int numEq,
41  void Assemble_addToSystemMatrix(escript::ASM_ptr S, int NN_Equa,                                  const std::vector<double>& array)
                                 const index_t* Nodes_Equa, int num_Equa,  
                                 int NN_Sol, const index_t* Nodes_Sol,  
                                 int num_Sol, const double* array)  
42  {  {
43      paso::SystemMatrix* pmat = dynamic_cast<paso::SystemMatrix*>(S.get());      paso::SystemMatrix* pmat = dynamic_cast<paso::SystemMatrix*>(S.get());
44      if (pmat) {      if (pmat) {
45          Assemble_addToSystemMatrix_Paso(pmat, NN_Equa, Nodes_Equa,          if (pmat->type & MATRIX_FORMAT_CSC) {
46                                          num_Equa, NN_Sol, Nodes_Sol,              addToSystemMatrixPasoCSC(pmat, Nodes, numEq, array);
47                                          num_Sol, array);          } else { // type == CSR
48                addToSystemMatrixPasoCSR(pmat, Nodes, numEq, array);
49            }
50          return;          return;
51      }      }
52  #if USE_TRILINOS  #if USE_TRILINOS
53      TrilinosMatrixAdapter* tmat(dynamic_cast<TrilinosMatrixAdapter*>(S.get()));      TrilinosMatrixAdapter* tmat(dynamic_cast<TrilinosMatrixAdapter*>(S.get()));
54      if (tmat) {      if (tmat) {
55          Assemble_addToSystemMatrix_Trilinos(tmat, NN_Equa, Nodes_Equa,          tmat->add(Nodes, array);
                                             num_Equa, NN_Sol, Nodes_Sol,  
                                             num_Sol, array);  
56          return;          return;
57      }      }
58  #endif  #endif
# Line 63  void Assemble_addToSystemMatrix(escript: Line 60  void Assemble_addToSystemMatrix(escript:
60                            "matrix type.");                            "matrix type.");
61  }  }
62    
63  void Assemble_addToSystemMatrix_Paso(paso::SystemMatrix* in, int NN_Equa,  void addToSystemMatrixPasoCSC(paso::SystemMatrix* in,
64                                       const index_t* Nodes_Equa, int num_Equa,                                const std::vector<index_t>& Nodes,
65                                       int NN_Sol, const index_t* Nodes_Sol,                                int numEq, const std::vector<double>& array)
                                      int num_Sol, const double* array)  
66  {  {
67      index_t index_offset = (in->type & MATRIX_FORMAT_OFFSET1 ? 1 : 0);      const int index_offset = (in->type & MATRIX_FORMAT_OFFSET1 ? 1 : 0);
68      dim_t k_Equa, j_Equa, j_Sol, k_Sol, i_Equa, i_Sol, l_col, l_row, ic, ir, k, i_row, i_col;      const int row_block_size = in->row_block_size;
69      index_t *mainBlock_ptr, *mainBlock_index, *col_coupleBlock_ptr, *col_coupleBlock_index, *row_coupleBlock_ptr,      const int col_block_size = in->col_block_size;
70      *row_coupleBlock_index;      const int block_size = in->block_size;
71      double *mainBlock_val, *row_coupleBlock_val, *col_coupleBlock_val;      const int num_subblocks_Eq = numEq / row_block_size;
72      dim_t row_block_size = in->row_block_size;      const int num_subblocks_Sol = numEq / col_block_size;
73      dim_t col_block_size = in->col_block_size;      const dim_t numMyCols = in->pattern->mainPattern->numInput;
74      dim_t block_size = in->block_size;      const dim_t numMyRows = in->pattern->mainPattern->numOutput;
75      dim_t num_subblocks_Equa = num_Equa / row_block_size;      const int NN = Nodes.size();
76      dim_t num_subblocks_Sol = num_Sol / col_block_size;  
77      dim_t numMyCols = in->pattern->mainPattern->numInput;      const index_t* mainBlock_ptr = in->mainBlock->pattern->ptr;
78      dim_t numMyRows = in->pattern->mainPattern->numOutput;      const index_t* mainBlock_index = in->mainBlock->pattern->index;
79        double* mainBlock_val = in->mainBlock->val;
80      if (in->type & MATRIX_FORMAT_CSC)      const index_t* col_coupleBlock_ptr = in->col_coupleBlock->pattern->ptr;
81      {      const index_t* col_coupleBlock_index = in->col_coupleBlock->pattern->index;
82      /* MATRIX_FORMAT_CSC does not support MPI !!!!! */      double* col_coupleBlock_val = in->col_coupleBlock->val;
83      mainBlock_ptr = in->mainBlock->pattern->ptr;      const index_t* row_coupleBlock_index = in->row_coupleBlock->pattern->index;
84      mainBlock_index = in->mainBlock->pattern->index;      double* row_coupleBlock_val = in->row_coupleBlock->val;
85      mainBlock_val = in->mainBlock->val;  
86      col_coupleBlock_ptr = in->col_coupleBlock->pattern->ptr;      for (int k_Sol = 0; k_Sol < NN; ++k_Sol) { // Down columns of array
87      col_coupleBlock_index = in->col_coupleBlock->pattern->index;          const index_t j_Sol = Nodes[k_Sol];
88      col_coupleBlock_val = in->col_coupleBlock->val;          for (int l_col = 0; l_col < num_subblocks_Sol; ++l_col) {
89      row_coupleBlock_ptr = in->row_coupleBlock->pattern->ptr;              const index_t i_col = j_Sol * num_subblocks_Sol + l_col;
90      row_coupleBlock_index = in->row_coupleBlock->pattern->index;              if (i_col < numMyCols) {
91      row_coupleBlock_val = in->row_coupleBlock->val;                  for (int k_Eq = 0; k_Eq < NN; ++k_Eq) {
92                        // Across cols of array
93      for (k_Sol = 0; k_Sol < NN_Sol; ++k_Sol)                      const index_t j_Eq = Nodes[k_Eq];
94      {           /* Down columns of array */                      for (int l_row = 0; l_row < num_subblocks_Eq; ++l_row) {
95          j_Sol = Nodes_Sol[k_Sol];                          const index_t i_row = j_Eq * num_subblocks_Eq + index_offset + l_row;
96          for (l_col = 0; l_col < num_subblocks_Sol; ++l_col)                          if (i_row < numMyRows + index_offset) {
97          {                              for (index_t k = mainBlock_ptr[i_col]-index_offset;
98          i_col = j_Sol * num_subblocks_Sol + l_col;                                   k < mainBlock_ptr[i_col + 1]-index_offset; ++k) {
99          if (i_col < numMyCols)                                  if (mainBlock_index[k] == i_row) {
100          {                                      // Entry array(k_Eq, j_Sol) is a block
101              for (k_Equa = 0; k_Equa < NN_Equa; ++k_Equa)                                      // (col_block_size x col_block_size)
102              {       /* Across cols of array */                                      for (int ic = 0; ic < col_block_size; ++ic) {
103              j_Equa = Nodes_Equa[k_Equa];                                          const int i_Sol = ic + col_block_size * l_col;
104              for (l_row = 0; l_row < num_subblocks_Equa; ++l_row)                                          for (int ir = 0; ir < row_block_size; ++ir) {
105              {                                              const int i_Eq = ir + row_block_size * l_row;
106                  i_row = j_Equa * num_subblocks_Equa + index_offset + l_row;                                              mainBlock_val[k*block_size + ir + row_block_size*ic] +=
107                  if (i_row < numMyRows + index_offset)                                                  array[INDEX4
108                  {                                                    (i_Eq, i_Sol, k_Eq, k_Sol, numEq, numEq, NN)];
109                  for (k = mainBlock_ptr[i_col] - index_offset;                                          }
110                       k < mainBlock_ptr[i_col + 1] - index_offset; ++k)                                      }
111                  {                                      break;
112                      if (mainBlock_index[k] == i_row)                                  }
113                      {                              }
114                      /* Entry array(k_Equa, j_Sol) is a block (col_block_size x col_block_size) */                          } else {
115                      for (ic = 0; ic < col_block_size; ++ic)                              for (index_t k = col_coupleBlock_ptr[i_col]-index_offset;
116                      {                                   k < col_coupleBlock_ptr[i_col + 1]-index_offset; ++k) {
117                          i_Sol = ic + col_block_size * l_col;;                                  if (row_coupleBlock_index[k] == i_row - numMyRows) {
118                          for (ir = 0; ir < row_block_size; ++ir)                                      for (int ic = 0; ic < col_block_size; ++ic) {
119                          {                                          const int i_Sol = ic + col_block_size * l_col;
120                          i_Equa = ir + row_block_size * l_row;                                          for (int ir = 0; ir < row_block_size; ++ir) {
121                          mainBlock_val[k * block_size + ir + row_block_size * ic] +=                                              const int i_Eq = ir + row_block_size * l_row;
122                              array[INDEX4                                              row_coupleBlock_val[k*block_size + ir + row_block_size*ic] +=
123                                (i_Equa, i_Sol, k_Equa, k_Sol, num_Equa, num_Sol, NN_Equa)];                                                  array[INDEX4
124                                                      (i_Eq, i_Sol, k_Eq, k_Sol, numEq, numEq, NN)];
125                                            }
126                                        }
127                                        break;
128                                    }
129                                }
130                            }
131                        }
132                    }
133                } else { // i_col >= numMyCols
134                    for (int k_Eq = 0; k_Eq < NN; ++k_Eq) {
135                        // Across rows of array
136                        const index_t j_Eq = Nodes[k_Eq];
137                        for (int l_row = 0; l_row < num_subblocks_Eq; ++l_row) {
138                            const index_t i_row = j_Eq * num_subblocks_Eq + index_offset + l_row;
139                            if (i_row < numMyRows + index_offset) {
140                                for (index_t k = col_coupleBlock_ptr[i_col-numMyCols]-index_offset;
141                                     k < col_coupleBlock_ptr[i_col - numMyCols + 1] - index_offset; ++k) {
142                                    if (col_coupleBlock_index[k] == i_row) {
143                                        for (int ic = 0; ic < col_block_size; ++ic) {
144                                            const int i_Sol = ic + col_block_size * l_col;
145                                            for (int ir = 0; ir < row_block_size; ++ir) {
146                                            const int i_Eq = ir + row_block_size * l_row;
147                                            col_coupleBlock_val[k*block_size + ir + row_block_size*ic] +=
148                                                array[INDEX4
149                                                  (i_Eq, i_Sol, k_Eq, k_Sol, numEq, numEq, NN)];
150                                            }
151                                        }
152                                        break;
153                                    }
154                                }
155                          }                          }
156                      }                      }
                     break;  
                     }  
                 }  
157                  }                  }
                 else  
                 {  
                 for (k = col_coupleBlock_ptr[i_col] - index_offset;  
                      k < col_coupleBlock_ptr[i_col + 1] - index_offset; ++k)  
                 {  
                     if (row_coupleBlock_index[k] == i_row - numMyRows)  
                     {  
                     for (ic = 0; ic < col_block_size; ++ic)  
                     {  
                         i_Sol = ic + col_block_size * l_col;  
                         for (ir = 0; ir < row_block_size; ++ir)  
                         {  
                         i_Equa = ir + row_block_size * l_row;  
                         row_coupleBlock_val[k * block_size + ir + row_block_size * ic] +=  
                             array[INDEX4  
                               (i_Equa, i_Sol, k_Equa, k_Sol, num_Equa, num_Sol, NN_Equa)];;  
                         }  
                     }  
                     break;  
                     }  
                 }  
                 }  
             }  
158              }              }
159          }          }
         else  
         {  
             for (k_Equa = 0; k_Equa < NN_Equa; ++k_Equa)  
             {       /* Across rows of array */  
             j_Equa = Nodes_Equa[k_Equa];  
             for (l_row = 0; l_row < num_subblocks_Equa; ++l_row)  
             {  
                 i_row = j_Equa * num_subblocks_Equa + index_offset + l_row;  
                 if (i_row < numMyRows + index_offset)  
                 {  
                 for (k = col_coupleBlock_ptr[i_col - numMyCols] - index_offset;  
                      k < col_coupleBlock_ptr[i_col - numMyCols + 1] - index_offset; ++k)  
                 {  
                     if (col_coupleBlock_index[k] == i_row)  
                     {  
                     for (ic = 0; ic < col_block_size; ++ic)  
                     {  
                         i_Sol = ic + col_block_size * l_col;  
                         for (ir = 0; ir < row_block_size; ++ir)  
                         {  
                         i_Equa = ir + row_block_size * l_row;  
                         col_coupleBlock_val[k * block_size + ir + row_block_size * ic] +=  
                             array[INDEX4  
                               (i_Equa, i_Sol, k_Equa, k_Sol, num_Equa, num_Sol, NN_Equa)];  
                         }  
                     }  
                     break;  
                     }  
                 }  
                 }  
             }  
             }  
         }  
         }  
160      }      }
161      }  }
162      else  
163      {  void addToSystemMatrixPasoCSR(paso::SystemMatrix* in,
164      mainBlock_ptr = in->mainBlock->pattern->ptr;                                const std::vector<index_t>& Nodes,
165      mainBlock_index = in->mainBlock->pattern->index;                                int numEq, const std::vector<double>& array)
166      mainBlock_val = in->mainBlock->val;  {
167      col_coupleBlock_ptr = in->col_coupleBlock->pattern->ptr;      const int index_offset = (in->type & MATRIX_FORMAT_OFFSET1 ? 1 : 0);
168      col_coupleBlock_index = in->col_coupleBlock->pattern->index;      const int row_block_size = in->row_block_size;
169      col_coupleBlock_val = in->col_coupleBlock->val;      const int col_block_size = in->col_block_size;
170      row_coupleBlock_ptr = in->row_coupleBlock->pattern->ptr;      const int block_size = in->block_size;
171      row_coupleBlock_index = in->row_coupleBlock->pattern->index;      const int num_subblocks_Eq = numEq / row_block_size;
172      row_coupleBlock_val = in->row_coupleBlock->val;      const int num_subblocks_Sol = numEq / col_block_size;
173        const dim_t numMyCols = in->pattern->mainPattern->numInput;
174      for (k_Equa = 0; k_Equa < NN_Equa; ++k_Equa)      const dim_t numMyRows = in->pattern->mainPattern->numOutput;
175      {           /* Down columns of array */      const int NN = Nodes.size();
176          j_Equa = Nodes_Equa[k_Equa];  
177          for (l_row = 0; l_row < num_subblocks_Equa; ++l_row)      const index_t* mainBlock_ptr = in->mainBlock->pattern->ptr;
178          {      const index_t* mainBlock_index = in->mainBlock->pattern->index;
179          i_row = j_Equa * num_subblocks_Equa + l_row;      double* mainBlock_val = in->mainBlock->val;
180          /* only look at the matrix rows stored on this processor */      const index_t* col_coupleBlock_ptr = in->col_coupleBlock->pattern->ptr;
181          if (i_row < numMyRows)      const index_t* col_coupleBlock_index = in->col_coupleBlock->pattern->index;
182          {      double* col_coupleBlock_val = in->col_coupleBlock->val;
183              for (k_Sol = 0; k_Sol < NN_Sol; ++k_Sol)      const index_t* row_coupleBlock_ptr = in->row_coupleBlock->pattern->ptr;
184              {       /* Across rows of array */      const index_t* row_coupleBlock_index = in->row_coupleBlock->pattern->index;
185              j_Sol = Nodes_Sol[k_Sol];      double* row_coupleBlock_val = in->row_coupleBlock->val;
186              for (l_col = 0; l_col < num_subblocks_Sol; ++l_col)  
187              {      for (int k_Eq = 0; k_Eq < NN; ++k_Eq) { // Down columns of array
188                  /* only look at the matrix rows stored on this processor */          const index_t j_Eq = Nodes[k_Eq];
189                  i_col = j_Sol * num_subblocks_Sol + index_offset + l_col;          for (int l_row = 0; l_row < num_subblocks_Eq; ++l_row) {
190                  if (i_col < numMyCols + index_offset)          const index_t i_row = j_Eq * num_subblocks_Eq + l_row;
191                  {          // only look at the matrix rows stored on this processor
192                  for (k = mainBlock_ptr[i_row] - index_offset;          if (i_row < numMyRows) {
193                       k < mainBlock_ptr[i_row + 1] - index_offset; ++k)              for (int k_Sol = 0; k_Sol < NN; ++k_Sol) { // Across rows of array
194                  {              const index_t j_Sol = Nodes[k_Sol];
195                      if (mainBlock_index[k] == i_col)              for (int l_col = 0; l_col < num_subblocks_Sol; ++l_col) {
196                      {                  // only look at the matrix rows stored on this processor
197                      /* Entry array(k_Sol, j_Equa) is a block (row_block_size x col_block_size) */                  const index_t i_col = j_Sol * num_subblocks_Sol + index_offset + l_col;
198                      for (ic = 0; ic < col_block_size; ++ic)                  if (i_col < numMyCols + index_offset) {
199                      {                      for (index_t k = mainBlock_ptr[i_row] - index_offset;
200                          i_Sol = ic + col_block_size * l_col;                           k < mainBlock_ptr[i_row + 1] - index_offset; ++k) {
201                          for (ir = 0; ir < row_block_size; ++ir)                          if (mainBlock_index[k] == i_col) {
202                          {                              // Entry array(k_Sol, j_Eq) is a block
203                          i_Equa = ir + row_block_size * l_row;                              // (row_block_size x col_block_size)
204                          mainBlock_val[k * block_size + ir + row_block_size * ic] +=                              for (int ic = 0; ic < col_block_size; ++ic) {
205                              array[INDEX4                                  const int i_Sol = ic + col_block_size * l_col;
206                                (i_Equa, i_Sol, k_Equa, k_Sol, num_Equa, num_Sol, NN_Equa)];                                  for (int ir = 0; ir < row_block_size; ++ir) {
207                          }                                      const int i_Eq = ir + row_block_size * l_row;
208                      }                                      mainBlock_val[k*block_size + ir + row_block_size*ic] +=
209                      break;                                          array[INDEX4
210                      }                                            (i_Eq, i_Sol, k_Eq, k_Sol, numEq, numEq, NN)];
211                  }                                  }
212                  }                              }
213                  else                              break;
214                  {                          }
215                  for (k = col_coupleBlock_ptr[i_row] - index_offset;                      }
216                       k < col_coupleBlock_ptr[i_row + 1] - index_offset; ++k)                  } else {
217                  {                      for (index_t k = col_coupleBlock_ptr[i_row] - index_offset;
218                      if (col_coupleBlock_index[k] == i_col - numMyCols)                           k < col_coupleBlock_ptr[i_row + 1] - index_offset; ++k) {
219                      {                          if (col_coupleBlock_index[k] == i_col - numMyCols) {
220                      /* Entry array(k_Sol, j_Equa) is a block (row_block_size x col_block_size) */                              // Entry array(k_Sol, j_Eq) is a block
221                      for (ic = 0; ic < col_block_size; ++ic)                              // (row_block_size x col_block_size)
222                      {                              for (int ic = 0; ic < col_block_size; ++ic) {
223                          i_Sol = ic + col_block_size * l_col;                                  const int i_Sol = ic + col_block_size * l_col;
224                          for (ir = 0; ir < row_block_size; ++ir)                                  for (int ir = 0; ir < row_block_size; ++ir) {
225                          {                                      const int i_Eq = ir+row_block_size*l_row;
226                          i_Equa = ir + row_block_size * l_row;                                      col_coupleBlock_val[k*block_size + ir + row_block_size*ic] +=
227                          col_coupleBlock_val[k * block_size + ir + row_block_size * ic] +=                                          array[INDEX4
228                              array[INDEX4                                            (i_Eq, i_Sol, k_Eq, k_Sol, numEq, numEq, NN)];
229                                (i_Equa, i_Sol, k_Equa, k_Sol, num_Equa, num_Sol, NN_Equa)];                                      }
230                          }                                  }
231                      }                                  break;
232                      break;                              }
233                      }                          }
234                  }                      }
235                  }                  }
236              }              }
237              }          } else {
238          }              for (int k_Sol = 0; k_Sol < NN; ++k_Sol) { // Across rows of array
239          else                  const index_t j_Sol = Nodes[k_Sol];
240          {                  for (int l_col = 0; l_col < num_subblocks_Sol; ++l_col) {
241              for (k_Sol = 0; k_Sol < NN_Sol; ++k_Sol)                      const index_t i_col = j_Sol * num_subblocks_Sol + index_offset + l_col;
242              {       /* Across rows of array */                      if (i_col < numMyCols + index_offset) {
243              j_Sol = Nodes_Sol[k_Sol];                          for (index_t k = row_coupleBlock_ptr[i_row - numMyRows] - index_offset;
244              for (l_col = 0; l_col < num_subblocks_Sol; ++l_col)                               k < row_coupleBlock_ptr[i_row - numMyRows + 1] - index_offset; ++k) {
245              {                              if (row_coupleBlock_index[k] == i_col) {
246                  i_col = j_Sol * num_subblocks_Sol + index_offset + l_col;                                  // Entry array(k_Sol, j_Eq) is a block
247                  if (i_col < numMyCols + index_offset)                                  // (row_block_size x col_block_size)
248                  {                                  for (int ic = 0; ic < col_block_size; ++ic) {
249                  for (k = row_coupleBlock_ptr[i_row - numMyRows] - index_offset;                                      const int i_Sol = ic + col_block_size * l_col;
250                       k < row_coupleBlock_ptr[i_row - numMyRows + 1] - index_offset; ++k)                                      for (int ir = 0; ir < row_block_size; ++ir) {
251                  {                                          const int i_Eq = ir + row_block_size * l_row;
252                      if (row_coupleBlock_index[k] == i_col)                                          row_coupleBlock_val[k*block_size + ir + row_block_size*ic] +=
253                      {                                              array[INDEX4
254                      /* Entry array(k_Sol, j_Equa) is a block (row_block_size x col_block_size) */                                                (i_Eq, i_Sol, k_Eq, k_Sol, numEq, numEq, NN)];
255                      for (ic = 0; ic < col_block_size; ++ic)                                          }
256                      {                                      }
257                          i_Sol = ic + col_block_size * l_col;                                      break;
258                          for (ir = 0; ir < row_block_size; ++ir)                                  }
259                          {                              }
                         i_Equa = ir + row_block_size * l_row;  
                         row_coupleBlock_val[k * block_size + ir + row_block_size * ic] +=  
                             array[INDEX4  
                               (i_Equa, i_Sol, k_Equa, k_Sol, num_Equa, num_Sol, NN_Equa)];  
260                          }                          }
261                      }                      }
                     break;  
                     }  
262                  }                  }
                 }  
             }  
263              }              }
264          }          }
         }  
265      }      }
     }  
 }  
   
 #if USE_TRILINOS  
 void Assemble_addToSystemMatrix_Trilinos(TrilinosMatrixAdapter* S, int NN_Equa,  
                                          const index_t* Nodes_Equa,  
                                          int num_Equa, int NN_Sol,  
                                          const index_t* Nodes_Sol, int num_Sol,  
                                          const double* array)  
 {  
     std::vector<index_t> rowIdx(Nodes_Equa, Nodes_Equa+NN_Equa);  
     std::vector<double> arr(array, array+(NN_Equa*NN_Sol*num_Sol*num_Equa));  
     S->add(rowIdx, arr);  
266  }  }
 #endif  
267    
268  } // namespace dudley  } // namespace dudley
269    

Legend:
Removed from v.6089  
changed lines
  Added in v.6090

  ViewVC Help
Powered by ViewVC 1.1.26