/[escript]/trunk/esys2/finley/src/finleyC/IndexList.c
ViewVC logotype

Diff of /trunk/esys2/finley/src/finleyC/IndexList.c

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

revision 97 by jgs, Tue Dec 14 05:39:33 2004 UTC revision 100 by jgs, Wed Dec 15 03:48:48 2004 UTC
# Line 22  Line 22 
22     triangle of the matrix is stored. */     triangle of the matrix is stored. */
23    
24  void Finley_IndexList_insertElements(Finley_IndexList* index_list, Finley_ElementFile* elements,  void Finley_IndexList_insertElements(Finley_IndexList* index_list, Finley_ElementFile* elements,
25                                         int reduce_row_order, maybelong* row_Label,                                         int reduce_row_order, int packed_row_block_size, maybelong* row_Label,
26                                         int reduce_col_order, maybelong* col_Label) {                                         int reduce_col_order, int packed_col_block_size, maybelong* col_Label,
27    maybelong e,kr,kc,NN_row,NN_col,i,icol,irow,color;                                         int symmetric, Finley_SystemMatrixType matType) {
28      maybelong e,kr,ir,kc,ic,NN_row,NN_col,i;
29      Finley_IndexList * tmp_list;
30      maybelong jr,jc,icol,irow,color;
31    
32    
33    if (elements!=NULL) {    if (elements!=NULL) {
34      maybelong NN=elements->ReferenceElement->Type->numNodes;      maybelong NN=elements->ReferenceElement->Type->numNodes;
# Line 44  void Finley_IndexList_insertElements(Fin Line 48  void Finley_IndexList_insertElements(Fin
48         row_node=id;         row_node=id;
49         NN_row=elements->ReferenceElement->Type->numNodes;         NN_row=elements->ReferenceElement->Type->numNodes;
50      }      }
51      for (color=0;color<elements->numColors;color++) {  
52          #pragma omp for private(e,irow,kr,kc,icol) schedule(static)      #pragma omp parallel private(color)
53          for (e=0;e<elements->numElements;e++) {      {
54              if (elements->Color[e]==color) {         switch(matType) {
55                  for (kr=0;kr<NN_row;kr++) {         case CSR:
56                    irow=row_Label[elements->Nodes[INDEX2(row_node[kr],e,NN)]];           if (symmetric) {
57                    for (kc=0;kc<NN_col;kc++) {              for (color=0;color<elements->numColors;color++) {
58                         icol=col_Label[elements->Nodes[INDEX2(col_node[kc],e,NN)]];                 #pragma omp for private(e,kr,jr,kc,jc,ir,irow,ic,icol,tmp_list) schedule(static)
59                         Finley_IndexList_insertIndex(&(index_list[irow]),icol);                 for (e=0;e<elements->numElements;e++) {
60                      if (elements->Color[e]==color) {
61                         for (kr=0;kr<NN_row;kr++) {
62                            jr=row_Label[elements->Nodes[INDEX2(row_node[kr],e,NN)]];
63                            for (ir=0;ir<packed_row_block_size;ir++) {
64                               irow=ir+packed_row_block_size*jr;
65                               tmp_list=&(index_list[irow]);
66                               for (kc=0;kc<NN_col;kc++) {
67                                  jc=col_Label[elements->Nodes[INDEX2(col_node[kc],e,NN)]];
68                                  for (ic=0;ic<packed_col_block_size;ic++) {
69                                     icol=ic+packed_col_block_size*jc;
70                                     if (irow<=icol) Finley_IndexList_insertIndex(tmp_list,icol);
71                                  }
72                               }
73                            }
74                         }
75                      }
76                   }
77                }
78             } else {
79                for (color=0;color<elements->numColors;color++) {
80                   #pragma omp for private(e,kr,jr,kc,jc,ir,irow,ic,icol,tmp_list) schedule(static)
81                   for (e=0;e<elements->numElements;e++) {
82                      if (elements->Color[e]==color) {
83                         for (kr=0;kr<NN_row;kr++) {
84                            jr=row_Label[elements->Nodes[INDEX2(row_node[kr],e,NN)]];
85                            for (ir=0;ir<packed_row_block_size;ir++) {
86                               irow=ir+packed_row_block_size*jr;
87                               tmp_list=&(index_list[irow]);
88                               for (kc=0;kc<NN_col;kc++) {
89                                  jc=col_Label[elements->Nodes[INDEX2(col_node[kc],e,NN)]];
90                                  for (ic=0;ic<packed_col_block_size;ic++) {                                  icol=ic+packed_col_block_size*jc;
91                                     Finley_IndexList_insertIndex(tmp_list,icol);
92                                  }
93                               }
94                            }
95                         }
96                      }
97                   }
98                }
99             } /* if else */
100             break;
101           case CSC:
102             if (symmetric) {
103                for (color=0;color<elements->numColors;color++) {
104                   #pragma omp for private (e,kr,jr,kc,jc,ir,irow,ic,icol,tmp_list) schedule(static)
105                   for (e=0;e<elements->numElements;e++) {
106                      if (elements->Color[e]==color) {
107                         for (kc=0;kc<NN_col;kc++) {
108                            jc=col_Label[elements->Nodes[INDEX2(col_node[kc],e,NN)]];
109                            for (ic=0;ic<packed_col_block_size;ic++) {
110                               icol=ic+packed_col_block_size*jc;
111                               tmp_list=&(index_list[icol]);
112                               for (kr=0;kr<NN_row;kr++) {
113                                  jr=row_Label[elements->Nodes[INDEX2(row_node[kr],e,NN)]];
114                                  for (ir=0;ir<packed_row_block_size;ir++) {
115                                     irow=ir+packed_row_block_size*jr;
116                                     if (irow<=icol) Finley_IndexList_insertIndex(tmp_list,irow);
117                                  }
118                               }
119                            }
120                         }
121                    }                    }
122                  }                 }
123              }              }
124          }           } else {
125        }             for (color=0;color<elements->numColors;color++) {
126                   #pragma omp for private (e,kr,jr,kc,jc,ir,irow,ic,icol,tmp_list) schedule(static)
127                   for (e=0;e<elements->numElements;e++) {
128                      if (elements->Color[e]==color) {
129                         for (kc=0;kc<NN_col;kc++) {
130                            jc=col_Label[elements->Nodes[INDEX2(col_node[kc],e,NN)]];
131                            for (ic=0;ic<packed_col_block_size;ic++) {
132                               icol=ic+packed_col_block_size*jc;
133                               tmp_list=&(index_list[icol]);
134                               for (kr=0;kr<NN_row;kr++) {
135                                  jr=row_Label[elements->Nodes[INDEX2(row_node[kr],e,NN)]];
136                                  for (ir=0;ir<packed_row_block_size;ir++) {
137                                     irow=ir+packed_row_block_size*jr;
138                                     Finley_IndexList_insertIndex(tmp_list,irow);
139                                  }
140                               }
141                            }
142                         }
143                      }
144                   }
145                }
146             } /* if else */
147           } /* switch matType */
148        }
149    }    }
150    return;    return;
151  }  }
# Line 68  void Finley_IndexList_insertIndex(Finley Line 156  void Finley_IndexList_insertIndex(Finley
156    int i;    int i;
157    /* is index in in? */    /* is index in in? */
158    for (i=0;i<in->n;i++) {    for (i=0;i<in->n;i++) {
159      if (in->index[i]==index)  return;      if (in->index[i]==index) return;
160    }    }
161    /* index could not be found */    /* index could not be found */
162    if (in->n==INDEXLIST_LENGTH) {    if (in->n==INDEXLIST_LENGTH) {
163       /* if in->index is full check the extension */       /* if in->index is full check the extension */
164       if (in->extension==NULL) {       if (in->extension==NULL) {
165          in->extension=TMPMEMALLOC(1,Finley_IndexList);          in->extension=(Finley_IndexList*) TMPMEMALLOC(sizeof(Finley_IndexList));
166          if (Finley_checkPtr(in->extension)) return;          if (Finley_checkPtr(in->extension)) return;
167          in->extension->n=0;          in->extension->n=0;
168          in->extension->extension=NULL;          in->extension->extension=NULL;
# Line 118  void Finley_IndexList_free(Finley_IndexL Line 206  void Finley_IndexList_free(Finley_IndexL
206    
207  /*  /*
208   * $Log$   * $Log$
209   * Revision 1.2  2004/12/14 05:39:30  jgs   * Revision 1.3  2004/12/15 03:48:45  jgs
210   * *** empty log message ***   * *** empty log message ***
211   *   *
  * Revision 1.1.1.1.2.2  2004/11/24 01:37:13  gross  
  * some changes dealing with the integer overflow in memory allocation. Finley solves 4M unknowns now  
  *  
  * Revision 1.1.1.1.2.1  2004/11/12 06:58:18  gross  
  * a lot of changes to get the linearPDE class running: most important change is that there is no matrix format exposed to the user anymore. the format is chosen by the Domain according to the solver and symmetry  
  *  
212   * Revision 1.1.1.1  2004/10/26 06:53:57  jgs   * Revision 1.1.1.1  2004/10/26 06:53:57  jgs
213   * initial import of project esys2   * initial import of project esys2
214   *   *

Legend:
Removed from v.97  
changed lines
  Added in v.100

  ViewVC Help
Powered by ViewVC 1.1.26