/[escript]/trunk/finley/src/Assemble_LumpedSystem.c
ViewVC logotype

Diff of /trunk/finley/src/Assemble_LumpedSystem.c

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

revision 2747 by jfenwick, Mon Jul 20 06:20:06 2009 UTC revision 2748 by gross, Tue Nov 17 07:32:59 2009 UTC
# Line 40  void Finley_Assemble_LumpedSystem(Finley Line 40  void Finley_Assemble_LumpedSystem(Finley
40    bool_t reducedIntegrationOrder=FALSE, expandedD;    bool_t reducedIntegrationOrder=FALSE, expandedD;
41    char error_msg[LenErrorMsg_MAX];    char error_msg[LenErrorMsg_MAX];
42    Assemble_Parameters p;    Assemble_Parameters p;
43    dim_t dimensions[ESCRIPT_MAX_DATA_RANK], k, e, len_EM_lumpedMat, q, s;    dim_t dimensions[ESCRIPT_MAX_DATA_RANK], k, e, len_EM_lumpedMat, q, s, isub;
44    type_t funcspace;    type_t funcspace;
45    index_t color,*row_index=NULL;    index_t color,*row_index=NULL;
46    __const double *D_p=NULL;    __const double *D_p=NULL;
47    double *S=NULL, *EM_lumpedMat=NULL, *Vol=NULL, *lumpedMat_p=NULL;    double *S=NULL, *EM_lumpedMat=NULL, *Vol=NULL, *lumpedMat_p=NULL;
48    register double rtmp;    register double rtmp;
49    size_t len_EM_lumpedMat_size;    size_t len_EM_lumpedMat_size;
50      #if (defined NEW_LUMPING) || (defined _OPENMP)
51  #ifdef NEW_LUMPING    register double m_t=0., diagS=0.;
52    register double m_t, diagS;    #endif
53  #endif  
   
54    Finley_resetError();    Finley_resetError();
55    
56    if (nodes==NULL || elements==NULL) return;    if (nodes==NULL || elements==NULL) return;
# Line 81  void Finley_Assemble_LumpedSystem(Finley Line 80  void Finley_Assemble_LumpedSystem(Finley
80    
81    /* check if all function spaces are the same */    /* check if all function spaces are the same */
82    
83    if (! numSamplesEqual(D,p.numQuad,elements->numElements) ) {    if (! numSamplesEqual(D,p.numQuadSub,elements->numElements) ) {
84          sprintf(error_msg,"Assemble_LumpedSystem: sample points of coefficient D don't match (%d,%d)",p.numQuad,elements->numElements);          sprintf(error_msg,"Assemble_LumpedSystem: sample points of coefficient D don't match (%d,%d)",p.numQuadSub,elements->numElements);
85          Finley_setError(TYPE_ERROR,error_msg);          Finley_setError(TYPE_ERROR,error_msg);
86    }    }
87    
# Line 109  void Finley_Assemble_LumpedSystem(Finley Line 108  void Finley_Assemble_LumpedSystem(Finley
108      void* buffer=allocSampleBuffer(D);      void* buffer=allocSampleBuffer(D);
109      requireWrite(lumpedMat);      requireWrite(lumpedMat);
110      lumpedMat_p=getSampleDataRW(lumpedMat,0);      lumpedMat_p=getSampleDataRW(lumpedMat,0);
111      len_EM_lumpedMat=p.row_NN*p.numEqu;      len_EM_lumpedMat=p.row_numShapesTotal*p.numEqu;
112      len_EM_lumpedMat_size=len_EM_lumpedMat*sizeof(double);      len_EM_lumpedMat_size=len_EM_lumpedMat*sizeof(double);
113        
114      expandedD=isExpanded(D);      expandedD=isExpanded(D);
115      S=p.row_jac->ReferenceElement->S;      S=p.row_jac->BasisFunctions->S;
116      #pragma omp parallel private(color, EM_lumpedMat, row_index, Vol, D_p, s, q, k, rtmp)      
117        #pragma omp parallel private(color, EM_lumpedMat, row_index, Vol, D_p, s, q, k, rtmp, diagS, m_t)
118      {      {
119         EM_lumpedMat=THREAD_MEMALLOC(len_EM_lumpedMat,double);         EM_lumpedMat=THREAD_MEMALLOC(len_EM_lumpedMat,double);
120         row_index=THREAD_MEMALLOC(p.row_NN,index_t);         row_index=THREAD_MEMALLOC(p.row_numShapesTotal,index_t);
121         if ( !Finley_checkPtr(EM_lumpedMat) && !Finley_checkPtr(row_index) ) {         if ( !Finley_checkPtr(EM_lumpedMat) && !Finley_checkPtr(row_index) ) {
122            if (p.numEqu == 1) {            if (p.numEqu == 1) {
123               if (expandedD) {               if (expandedD) {
124                
125                   for (color=elements->minColor;color<=elements->maxColor;color++) {                   for (color=elements->minColor;color<=elements->maxColor;color++) {
126                      /*  open loop over all elements: */                      /*  open loop over all elements: */
127                      #pragma omp for private(e) schedule(static)                      #pragma omp for private(e) schedule(static)
128                      for(e=0;e<elements->numElements;e++){                      for(e=0;e<elements->numElements;e++){
129                         if (elements->Color[e]==color) {                      
130                            Vol=&(p.row_jac->volume[INDEX2(0,e,p.numQuad)]);                          if (elements->Color[e]==color) {
131                            memset(EM_lumpedMat,0,len_EM_lumpedMat_size);                              for (isub=0; isub<p.numSub; isub++) {
132                            D_p=getSampleDataRO(D,e,buffer);                                 Vol=&(p.row_jac->volume[INDEX3(0,isub,e, p.numQuadSub,p.numSub)]);
133                            #ifdef NEW_LUMPING /* HRZ lumping */                                 memset(EM_lumpedMat,0,len_EM_lumpedMat_size);
134                            /*                  
135                             *           Number of PDEs: 1                                 D_p=getSampleDataRO(D,e,buffer);                          
136                             *  D_p varies over element: True                                 #ifdef NEW_LUMPING /* HRZ lumping */
137                             */                                     m_t=0; /* mass of the element: m_t */
138                            #pragma omp parallel private(m_t)                                     for (q=0;q<p.numQuadSub;q++) m_t+=Vol[q]*D_p[INDEX2(q, isub,p.numQuadSub) ];
139                            m_t=0; /* mass of the element: m_t */                          
140                            for (q=0;q<p.numQuad;q++) {                                     diagS=0; /* diagonal sum: S */
141                                m_t+=Vol[q]*D_p[q];                                     for (s=0;s<p.row_numShapes;s++) {
142                            }                                                                  rtmp=0;
143                            #pragma omp parallel private(diagS)                                        for (q=0;q<p.numQuadSub;q++) rtmp+=Vol[q]*D_p[INDEX2(q, isub,p.numQuadSub)]*S[INDEX2(s,q,p.row_numShapes)]*S[INDEX2(s,q,p.row_numShapes)];
144                            diagS=0; /* diagonal sum: S */                                        EM_lumpedMat[INDEX2(0,s,p.numEqu)]=rtmp;
145                            for (s=0;s<p.row_NS;s++) {                                        diagS+=rtmp;
146                                rtmp=0;                                     }
147                                for (q=0;q<p.numQuad;q++) {                                     /* rescale diagonals by m_t/diagS to ensure consistent mass over element */
148                                    rtmp+=Vol[q]*D_p[q]*S[INDEX2(s,q,p.row_NS)]*S[INDEX2(s,q,p.row_NS)];                                     rtmp=m_t/diagS;
149                                }                                     for (s=0;s<p.row_numShapes;s++) EM_lumpedMat[INDEX2(0,s,p.numEqu)]*=rtmp;
150                                EM_lumpedMat[INDEX2(0,s,p.numEqu)]+=rtmp;                            
151                                diagS+=EM_lumpedMat[INDEX2(0,s,p.numEqu)];                                 #else /* row-sum lumping */
152                            }                                     for (s=0;s<p.row_numShapes;s++) {
153                            /* rescale diagonals by m_t/diagS to ensure consistent mass over element */                                         rtmp=0;
154                            for (s=0;s<p.row_NS;s++) {                                         for (q=0;q<p.numQuadSub;q++) rtmp+=Vol[q]*S[INDEX2(s,q,p.row_numShapes)]*D_p[INDEX2(q, isub,p.numQuadSub)];
155                                EM_lumpedMat[INDEX2(0,s,p.numEqu)]*=m_t/diagS;                                         EM_lumpedMat[INDEX2(0,s,p.numEqu)]+=rtmp;
156                            }                                     }
157                            #else /* row-sum lumping */                                 #endif
158                            for (s=0;s<p.row_NS;s++) {                                 for (q=0;q<p.row_numShapesTotal;q++) row_index[q]=p.row_DOF[elements->Nodes[INDEX2(p.row_node[INDEX2(q,isub,p.row_numShapesTotal)],e,p.NN)]];
159                                rtmp=0;                                 Finley_Util_AddScatter(p.row_numShapesTotal,row_index,p.numEqu,EM_lumpedMat,lumpedMat_p, p.row_DOF_UpperBound);
160                                for (q=0;q<p.numQuad;q++) rtmp+=Vol[q]*S[INDEX2(s,q,p.row_NS)]*D_p[q];                  } /* end of isub loop */
                               EM_lumpedMat[INDEX2(0,s,p.numEqu)]+=rtmp;  
                           }  
                           #endif  
                           for (q=0;q<p.row_NN;q++) row_index[q]=p.row_DOF[elements->Nodes[INDEX2(p.row_node[q],e,p.NN)]];  
                           Finley_Util_AddScatter(p.row_NN,row_index,p.numEqu,EM_lumpedMat,lumpedMat_p, p.row_DOF_UpperBound);  
161                         } /* end color check */                         } /* end color check */
162                  
163                      } /* end element loop */                      } /* end element loop */
164                    } /* end color loop */                    } /* end color loop */
165               } else  {               } else  {          
166                   for (color=elements->minColor;color<=elements->maxColor;color++) {                   for (color=elements->minColor;color<=elements->maxColor;color++) {
167                   /*  open loop over all elements: */                      /*  open loop over all elements: */
168                   #pragma omp for private(e) schedule(static)                      #pragma omp for private(e) schedule(static)
169                   for(e=0;e<elements->numElements;e++){                      for(e=0;e<elements->numElements;e++){
170                      if (elements->Color[e]==color) {                      
171                            Vol=&(p.row_jac->volume[INDEX2(0,e,p.numQuad)]);                          if (elements->Color[e]==color) {
172                            memset(EM_lumpedMat,0,len_EM_lumpedMat_size);                              for (isub=0; isub<p.numSub; isub++) {
173                            D_p=getSampleDataRO(D,e,buffer);                              
174                            #ifdef NEW_LUMPING /* HRZ lumping */                                  Vol=&(p.row_jac->volume[INDEX3(0,isub,e, p.numQuadSub,p.numSub)]);
175                            /*                                  memset(EM_lumpedMat,0,len_EM_lumpedMat_size);
176                             *           Number of PDEs: 1                  
177                             *  D_p varies over element: False                                 D_p=getSampleDataRO(D,e,buffer);                          
178                             */                                 #ifdef NEW_LUMPING /* HRZ lumping */
179                            m_t=0; /* mass of the element: m_t */                                     m_t=0; /* mass of the element: m_t */
180                            for (q=0;q<p.numQuad;q++) {                                     for (q=0;q<p.numQuadSub;q++) m_t+=Vol[q];
181                                m_t+=Vol[q]*D_p[0];                                     m_t*=D_p[0];
182                            }                                              
183                            diagS=0; /* diagonal sum: S */                                     diagS=0; /* diagonal sum: S */
184                            for (s=0;s<p.row_NS;s++) {                                     for (s=0;s<p.row_numShapes;s++) {
185                                rtmp=0;                                        rtmp=0;
186                                for (q=0;q<p.numQuad;q++) {                                        for (q=0;q<p.numQuadSub;q++) rtmp+=Vol[q]*S[INDEX2(s,q,p.row_numShapes)]*S[INDEX2(s,q,p.row_numShapes)];
187                                    rtmp+=Vol[q]*D_p[0]*S[INDEX2(s,q,p.row_NS)]*S[INDEX2(s,q,p.row_NS)];                                        rtmp*=D_p[0];
188                                }                                        EM_lumpedMat[INDEX2(0,s,p.numEqu)]=rtmp;
189                                EM_lumpedMat[INDEX2(0,s,p.numEqu)]+=rtmp;                                        diagS+=rtmp;
190                                diagS+=EM_lumpedMat[INDEX2(0,s,p.numEqu)];                                     }
191                            }                                     /* rescale diagonals by m_t/diagS to ensure consistent mass over element */
192                            /* rescale diagonals by m_t/diagS to ensure consistent mass over element */                                     rtmp=m_t/diagS;
193                            for (s=0;s<p.row_NS;s++) {                                     for (s=0;s<p.row_numShapes;s++) EM_lumpedMat[INDEX2(0,s,p.numEqu)]*=rtmp;
194                                EM_lumpedMat[INDEX2(0,s,p.numEqu)]*=m_t/diagS;                            
195                            }                                 #else /* row-sum lumping */
196                            #else /* row-sum lumping */                                     for (s=0;s<p.row_numShapes;s++) {
197                            for (s=0;s<p.row_NS;s++) {                                         rtmp=0;
198                                rtmp=0;                                         for (q=0;q<p.numQuadSub;q++) rtmp+=Vol[q]*S[INDEX2(s,q,p.row_numShapes)];
199                                for (q=0;q<p.numQuad;q++) rtmp+=Vol[q]*S[INDEX2(s,q,p.row_NS)];                                         EM_lumpedMat[INDEX2(0,s,p.numEqu)]+=rtmp*D_p[0];
200                                EM_lumpedMat[INDEX2(0,s,p.numEqu)]+=rtmp*D_p[0];                                     }
201                            }                                 #endif
202                            #endif                                 for (q=0;q<p.row_numShapesTotal;q++) row_index[q]=p.row_DOF[elements->Nodes[INDEX2(p.row_node[INDEX2(q,isub,p.row_numShapesTotal)],e,p.NN)]];
203                            for (q=0;q<p.row_NN;q++) row_index[q]=p.row_DOF[elements->Nodes[INDEX2(p.row_node[q],e,p.NN)]];                                 Finley_Util_AddScatter(p.row_numShapesTotal,row_index,p.numEqu,EM_lumpedMat,lumpedMat_p, p.row_DOF_UpperBound);
204                            Finley_Util_AddScatter(p.row_NN,row_index,p.numEqu,EM_lumpedMat,lumpedMat_p, p.row_DOF_UpperBound);                              } /* end of isub loop */
205                        } /* end color check */                         } /* end color check */
206                      } /* end element loop */                      } /* end element loop */
207                   } /* end color loop */                    } /* end color loop */
208            
209               }               }
210            } else {            } else {
211               if (expandedD) {               if (expandedD) {
# Line 215  void Finley_Assemble_LumpedSystem(Finley Line 214  void Finley_Assemble_LumpedSystem(Finley
214                      #pragma omp for private(e) schedule(static)                      #pragma omp for private(e) schedule(static)
215                      for(e=0;e<elements->numElements;e++){                      for(e=0;e<elements->numElements;e++){
216                         if (elements->Color[e]==color) {                         if (elements->Color[e]==color) {
217                            Vol=&(p.row_jac->volume[INDEX2(0,e,p.numQuad)]);                             for (isub=0; isub<p.numSub; isub++) {    
218                            memset(EM_lumpedMat,0,len_EM_lumpedMat_size);                                Vol=&(p.row_jac->volume[INDEX3(0,isub,e, p.numQuadSub,p.numSub)]);
219                            D_p=getSampleDataRO(D,e,buffer);                                memset(EM_lumpedMat,0,len_EM_lumpedMat_size);
220                            #ifdef NEW_LUMPING /* HRZ lumping */                                D_p=getSampleDataRO(D,e,buffer);
221                            /*                
222                             *           Number of PDEs: Multiple                                #ifdef NEW_LUMPING /* HRZ lumping */
223                             *  D_p varies over element: True                                    for (k=0;k<p.numEqu;k++) {
224                             */                                        m_t=0; /* mass of the element: m_t */
225                            for (k=0;k<p.numEqu;k++) {                                        for (q=0;q<p.numQuadSub;q++) m_t+=Vol[q]*D_p[INDEX3(k,q,isub,p.numEqu,p.numQuadSub)];
226                                m_t=0; /* mass of the element: m_t */                                                    
227                                for (q=0;q<p.numQuad;q++) {                                        diagS=0; /* diagonal sum: S */
228                                    m_t+=Vol[q]*D_p[INDEX2(k,q,p.numEqu)];                                        for (s=0;s<p.row_numShapes;s++) {
229                                }                                                                      rtmp=0;
230                                diagS=0; /* diagonal sum: S */                                            for (q=0;q<p.numQuadSub;q++) rtmp+=Vol[q]*D_p[INDEX3(k,q,isub,p.numEqu,p.numQuadSub)]*S[INDEX2(s,q,p.row_numShapes)]*S[INDEX2(s,q,p.row_numShapes)];
231                                for (s=0;s<p.row_NS;s++) {                                            EM_lumpedMat[INDEX2(k,s,p.numEqu)]=rtmp;
232                                    rtmp=0;                                            diagS+=rtmp;
233                                    for (q=0;q<p.numQuad;q++) {                                        }
234                                        rtmp+=Vol[q]*D_p[INDEX2(k,q,p.numEqu)]*S[INDEX2(s,q,p.row_NS)]*S[INDEX2(s,q,p.row_NS)];                                        /* rescale diagonals by m_t/diagS to ensure consistent mass over element */
235                                          rtmp=m_t/diagS;
236                                          for (s=0;s<p.row_numShapes;s++) EM_lumpedMat[INDEX2(k,s,p.numEqu)]*=rtmp;
237                                      }
238                                  #else /* row-sum lumping */
239                                    for (s=0;s<p.row_numShapes;s++) {
240                                      for (k=0;k<p.numEqu;k++) {
241                                          rtmp=0.;
242                                          for (q=0;q<p.numQuadSub;q++) rtmp+=Vol[q]*S[INDEX2(s,q,p.row_numShapes)]*D_p[INDEX3(k,q,isub,p.numEqu,p.numQuadSub)];
243                                          EM_lumpedMat[INDEX2(k,s,p.numEqu)]+=rtmp;
244                                    }                                    }
245                                    EM_lumpedMat[INDEX2(k,s,p.numEqu)]+=rtmp;                                  }
246                                    diagS+=EM_lumpedMat[INDEX2(k,s,p.numEqu)];                                #endif
247                                }                                for (q=0;q<p.row_numShapesTotal;q++) row_index[q]=p.row_DOF[elements->Nodes[INDEX2(p.row_node[INDEX2(q,isub,p.row_numShapesTotal)],e,p.NN)]];
248                                /* rescale diagonals by m_t/diagS to ensure consistent mass over element */                                Finley_Util_AddScatter(p.row_numShapesTotal,row_index,p.numEqu,EM_lumpedMat,lumpedMat_p, p.row_DOF_UpperBound);
249                                for (s=0;s<p.row_NS;s++) {                             } /* end of isub loop */
                                   EM_lumpedMat[INDEX2(k,s,p.numEqu)]*=m_t/diagS;  
                               }  
                           }  
                           #else /* row-sum lumping */  
                           for (s=0;s<p.row_NS;s++) {  
                               for (k=0;k<p.numEqu;k++) {  
                                   rtmp=0.;  
                                   for (q=0;q<p.numQuad;q++) rtmp+=Vol[q]*S[INDEX2(s,q,p.row_NS)]*D_p[INDEX2(k,q,p.numEqu)];  
                                   EM_lumpedMat[INDEX2(k,s,p.numEqu)]+=rtmp;  
                               }  
                           }  
                           #endif  
                           for (q=0;q<p.row_NN;q++) row_index[q]=p.row_DOF[elements->Nodes[INDEX2(p.row_node[q],e,p.NN)]];  
                           Finley_Util_AddScatter(p.row_NN,row_index,p.numEqu,EM_lumpedMat,lumpedMat_p, p.row_DOF_UpperBound);  
250                         } /* end color check */                         } /* end color check */
251                      } /* end element loop */                      } /* end element loop */
252                  } /* end color loop */                  } /* end color loop */
253               } else {               } else {
                  /*  open loop over all elements: */  
254                   for (color=elements->minColor;color<=elements->maxColor;color++) {                   for (color=elements->minColor;color<=elements->maxColor;color++) {
255                        /*  open loop over all elements: */
256                      #pragma omp for private(e) schedule(static)                      #pragma omp for private(e) schedule(static)
257                      for(e=0;e<elements->numElements;e++){                      for(e=0;e<elements->numElements;e++){
258                         if (elements->Color[e]==color) {                         if (elements->Color[e]==color) {
259                            Vol=&(p.row_jac->volume[INDEX2(0,e,p.numQuad)]);                             for (isub=0; isub<p.numSub; isub++) {    
260                            memset(EM_lumpedMat,0,len_EM_lumpedMat_size);                                Vol=&(p.row_jac->volume[INDEX3(0,isub,e, p.numQuadSub,p.numSub)]);
261                            D_p=getSampleDataRO(D,e,buffer);                                memset(EM_lumpedMat,0,len_EM_lumpedMat_size);
262                            #ifdef NEW_LUMPING /* HRZ lumping */                                D_p=getSampleDataRO(D,e,buffer);
263                            /*                
264                             *           Number of PDEs: Multiple                                #ifdef NEW_LUMPING /* HRZ lumping */
265                             *  D_p varies over element: False                                    for (k=0;k<p.numEqu;k++) {
266                             */                                        m_t=0; /* mass of the element: m_t */
267                            for (k=0;k<p.numEqu;k++) {                                        for (q=0;q<p.numQuadSub;q++) m_t+=Vol[q]*D_p[INDEX3(k,q,isub,p.numEqu,p.numQuadSub)];
268                                m_t=0; /* mass of the element: m_t */                                        m_t*=D_p[k];          
269                                for (q=0;q<p.numQuad;q++) {                                        diagS=0; /* diagonal sum: S */
270                                    m_t+=Vol[q]*D_p[k];                                        for (s=0;s<p.row_numShapes;s++) {
271                                }                                                                      rtmp=0;
272                                diagS=0; /* diagonal sum: S */                                            for (q=0;q<p.numQuadSub;q++) rtmp+=Vol[q]*S[INDEX2(s,q,p.row_numShapes)]*S[INDEX2(s,q,p.row_numShapes)];
273                                for (s=0;s<p.row_NS;s++) {                                            rtmp*=D_p[k];
274                                    rtmp=0;                                            EM_lumpedMat[INDEX2(k,s,p.numEqu)]=rtmp;
275                                    for (q=0;q<p.numQuad;q++) {                                            diagS+=rtmp;
276                                        rtmp+=Vol[q]*D_p[k]*S[INDEX2(s,q,p.row_NS)]*S[INDEX2(s,q,p.row_NS)];                                        }
277                                    }                                        /* rescale diagonals by m_t/diagS to ensure consistent mass over element */
278                                    EM_lumpedMat[INDEX2(k,s,p.numEqu)]+=rtmp;                                        rtmp=m_t/diagS;
279                                    diagS+=EM_lumpedMat[INDEX2(k,s,p.numEqu)];                                        for (s=0;s<p.row_numShapes;s++) EM_lumpedMat[INDEX2(k,s,p.numEqu)]*=rtmp;
280                                }                                    }
281                                /* rescale diagonals by m_t/diagS to ensure consistent mass over element */                               #else /* row-sum lumping */
282                                for (s=0;s<p.row_NS;s++) {                                   for (s=0;s<p.row_numShapes;s++) {
283                                    EM_lumpedMat[INDEX2(k,s,p.numEqu)]*=m_t/diagS;                                       for (k=0;k<p.numEqu;k++) {
284                                }                                          rtmp=0.;
285                            }                                          for (q=0;q<p.numQuadSub;q++) rtmp+=Vol[q]*S[INDEX2(s,q,p.row_numShapes)];
286                            #else /* row-sum lumping */                                          EM_lumpedMat[INDEX2(k,s,p.numEqu)]+=rtmp*D_p[k];
287                            for (s=0;s<p.row_NS;s++) {                                       }
288                                rtmp=0;                                   }
289                                for (q=0;q<p.numQuad;q++) rtmp+=Vol[q]*S[INDEX2(s,q,p.row_NS)];                                #endif
290                                for (k=0;k<p.numEqu;k++) EM_lumpedMat[INDEX2(k,s,p.numEqu)]+=rtmp*D_p[k];                                for (q=0;q<p.row_numShapesTotal;q++) row_index[q]=p.row_DOF[elements->Nodes[INDEX2(p.row_node[INDEX2(q,isub,p.row_numShapesTotal)],e,p.NN)]];
291                            }                                Finley_Util_AddScatter(p.row_numShapesTotal,row_index,p.numEqu,EM_lumpedMat,lumpedMat_p, p.row_DOF_UpperBound);
292                            #endif                            } /* end of isub loop */
                           for (q=0;q<p.row_NN;q++) row_index[q]=p.row_DOF[elements->Nodes[INDEX2(p.row_node[q],e,p.NN)]];  
                           Finley_Util_AddScatter(p.row_NN,row_index,p.numEqu,EM_lumpedMat,lumpedMat_p, p.row_DOF_UpperBound);  
293                         } /* end color check */                         } /* end color check */
294                      } /* end element loop */                      } /* end element loop */
295                  } /* end color loop */                  } /* end color loop */

Legend:
Removed from v.2747  
changed lines
  Added in v.2748

  ViewVC Help
Powered by ViewVC 1.1.26