/[escript]/trunk-mpi-branch/finley/src/Assemble_gradient.c
ViewVC logotype

Diff of /trunk-mpi-branch/finley/src/Assemble_gradient.c

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

revision 1270 by gross, Fri Aug 3 02:40:39 2007 UTC revision 1271 by gross, Thu Aug 23 08:05:04 2007 UTC
# Line 12  Line 12 
12    
13  /**************************************************************/  /**************************************************************/
14    
15  /*    assemblage rjacines: calculate the gradient of nodal data at quadrature points */  /*    assemblage jacobiens: calculate the gradient of nodal data at quadrature points */
16    
17  /**************************************************************/  /**************************************************************/
18    
# Line 33  Line 33 
33  void Finley_Assemble_gradient(Finley_NodeFile* nodes, Finley_ElementFile* elements,  void Finley_Assemble_gradient(Finley_NodeFile* nodes, Finley_ElementFile* elements,
34                                escriptDataC* grad_data,escriptDataC* data) {                                escriptDataC* grad_data,escriptDataC* data) {
35    
36      register dim_t e,q,l,s,n;
37      register double* data_array,  *grad_data_e;
38    dim_t numNodes, numShapes, numLocalNodes, numComps, NN;    dim_t numNodes, numShapes, numLocalNodes, numComps, NN;
39    type_t data_type=getFunctionSpaceType(data);    type_t data_type=getFunctionSpaceType(data);
40    bool_t reducedShapefunction=FALSE, reducedIntegrationOrder=FALSE;    bool_t reducedShapefunction=FALSE, reducedIntegrationOrder=FALSE;
   Finley_NodeMapping *mapping=NULL;  
41    index_t dof_offset, s_offset;    index_t dof_offset, s_offset;
42    Finley_ElementFile_Jacobeans* jac=NULL;    Finley_ElementFile_Jacobeans* jac=NULL;
43    type_t grad_data_type=getFunctionSpaceType(grad_data);    type_t grad_data_type=getFunctionSpaceType(grad_data);
44    Finley_resetError();    Finley_resetError();
45    if (nodes==NULL || elements==NULL) return;    if (nodes==NULL || elements==NULL) return;
46    numComps=getDataPointSize(data);    numComps=getDataPointSize(data);
47    NN=elements->ReferenceElement->Type->numNodes;    NN=elements->numNodes;
48    reducedIntegrationOrder=Finley_Assemble_reducedIntegrationOrder(grad_data);    reducedIntegrationOrder=Finley_Assemble_reducedIntegrationOrder(grad_data);
49    
50    if (data_type==FINLEY_NODES) {    if (data_type==FINLEY_NODES) {
51         reducedShapefunction=FALSE;         reducedShapefunction=FALSE;
52         mapping=nodes->nodesMapping;         numNodes=nodes->nodesMapping->numTargets;
53    } else if (data_type==FINLEY_REDUCED_NODES) {    } else if (data_type==FINLEY_REDUCED_NODES) {
54         reducedShapefunction=TRUE;         reducedShapefunction=TRUE;
55         mapping=nodes->reducedNodesMapping;         numNodes=nodes->reducedNodesMapping->numTargets;
56    } else if (data_type==FINLEY_DEGREES_OF_FREEDOM) {    } else if (data_type==FINLEY_DEGREES_OF_FREEDOM) {
57         if (elements->MPIInfo->size>1) {         if (elements->MPIInfo->size>1) {
58            Finley_setError(TYPE_ERROR,"Finley_Assemble_gradient: for more than one processor DEGREES_OF_FREEDOM data are not accepted as input.");            Finley_setError(TYPE_ERROR,"Finley_Assemble_gradient: for more than one processor DEGREES_OF_FREEDOM data are not accepted as input.");
59            return;            return;
60         }         }
61         reducedShapefunction=FALSE;         reducedShapefunction=FALSE;
62         mapping=nodes->degreesOfFreedomMapping;         numNodes=nodes->degreesOfFreedomMapping->numTargets;
63    } else if (data_type==FINLEY_REDUCED_DEGREES_OF_FREEDOM) {    } else if (data_type==FINLEY_REDUCED_DEGREES_OF_FREEDOM) {
64         if (elements->MPIInfo->size>1) {         if (elements->MPIInfo->size>1) {
65            Finley_setError(TYPE_ERROR,"Finley_Assemble_gradient: for more than one processor REDUCED_DEGREES_OF_FREEDOM data are not accepted as input.");            Finley_setError(TYPE_ERROR,"Finley_Assemble_gradient: for more than one processor REDUCED_DEGREES_OF_FREEDOM data are not accepted as input.");
66            return;            return;
67         }         }
68         reducedShapefunction=TRUE;         reducedShapefunction=TRUE;
69         mapping=nodes->reducedDegreesOfFreedomMapping;         numNodes=nodes->reducedDegreesOfFreedomMapping->numTargets;
70    } else {    } else {
71         Finley_setError(TYPE_ERROR,"Finley_Assemble_gradient: Cannot calculate gradient of data because of unsuitable input data representation.");         Finley_setError(TYPE_ERROR,"Finley_Assemble_gradient: Cannot calculate gradient of data because of unsuitable input data representation.");
72    }    }
# Line 87  void Finley_Assemble_gradient(Finley_Nod Line 88  void Finley_Assemble_gradient(Finley_Nod
88    
89        if (! numSamplesEqual(grad_data,jac->ReferenceElement->numQuadNodes,elements->numElements)) {        if (! numSamplesEqual(grad_data,jac->ReferenceElement->numQuadNodes,elements->numElements)) {
90             Finley_setError(TYPE_ERROR,"Finley_Assemble_gradient: illegal number of samples in gradient Data object");             Finley_setError(TYPE_ERROR,"Finley_Assemble_gradient: illegal number of samples in gradient Data object");
91        } else if (! numSamplesEqual(data,1,mapping->numTargets)) {        } else if (! numSamplesEqual(data,1,numNodes)) {
92             Finley_setError(TYPE_ERROR,"Finley_Assemble_gradient: illegal number of samples of input Data object");             Finley_setError(TYPE_ERROR,"Finley_Assemble_gradient: illegal number of samples of input Data object");
93        } else if (jac->numDim*numComps!=getDataPointSize(grad_data)) {        } else if (jac->numDim*numComps!=getDataPointSize(grad_data)) {
94             Finley_setError(TYPE_ERROR,"Finley_Assemble_gradient: illegal number of components in gradient data object.");             Finley_setError(TYPE_ERROR,"Finley_Assemble_gradient: illegal number of components in gradient data object.");
# Line 100  void Finley_Assemble_gradient(Finley_Nod Line 101  void Finley_Assemble_gradient(Finley_Nod
101        }        }
102    }    }
103    /* now we can start */    /* now we can start */
   
104    if (Finley_noError()) {    if (Finley_noError()) {
       register dim_t e,q,l,s,n;  
       register double* data_array,  *grad_data_e;  
105        #pragma omp parallel private(e,q,l,s,n,data_array,grad_data_e)        #pragma omp parallel private(e,q,l,s,n,data_array,grad_data_e)
106        {        {
107           if (jac->numDim==1) {           if (data_type==FINLEY_NODES) {
108                if (jac->numDim==1) {
109                  #define DIM 1                  #define DIM 1
110                  #pragma omp for schedule(static)                  #pragma omp for schedule(static)
111              for (e=0;e<elements->numElements;e++) {              for (e=0;e<elements->numElements;e++) {
112                      grad_data_e=getSampleData(grad_data,e);                      grad_data_e=getSampleData(grad_data,e);
113                      for (q=0;q<DIM*(jac->ReferenceElement->numQuadNodes)*numComps; q++) grad_data_e[q]=0;                      for (q=0;q<DIM*(jac->ReferenceElement->numQuadNodes)*numComps; q++) grad_data_e[q]=0;
114                      for (s=0;s<jac->ReferenceElement->Type->numShapes;s++) {                      for (s=0;s<jac->ReferenceElement->Type->numShapes;s++) {
115                         n=mapping->target[elements->Nodes[INDEX2(dof_offset+s,e,NN)]];                         n=elements->Nodes[INDEX2(dof_offset+s,e,NN)];
116                         data_array=getSampleData(data,n);                         data_array=getSampleData(data,n);
117                         for (q=0;q<jac->ReferenceElement->numQuadNodes;q++) {                         for (q=0;q<jac->ReferenceElement->numQuadNodes;q++) {
118                             for (l=0;l<numComps;l++) {                             for (l=0;l<numComps;l++) {
# Line 125  void Finley_Assemble_gradient(Finley_Nod Line 124  void Finley_Assemble_gradient(Finley_Nod
124                  }                  }
125    
126                  #undef DIM                  #undef DIM
127           } else if (jac->numDim==2) {              } else if (jac->numDim==2) {
128                  #define DIM 2                  #define DIM 2
129                  #pragma omp for schedule(static)                  #pragma omp for schedule(static)
130              for (e=0;e<elements->numElements;e++) {              for (e=0;e<elements->numElements;e++) {
131                      grad_data_e=getSampleData(grad_data,e);                      grad_data_e=getSampleData(grad_data,e);
132                      for (q=0;q<DIM*(jac->ReferenceElement->numQuadNodes)*numComps; q++) grad_data_e[q]=0;                      for (q=0;q<DIM*(jac->ReferenceElement->numQuadNodes)*numComps; q++) grad_data_e[q]=0;
133                      for (s=0;s<jac->ReferenceElement->Type->numShapes;s++) {                      for (s=0;s<jac->ReferenceElement->Type->numShapes;s++) {
134                         n=mapping->target[elements->Nodes[INDEX2(dof_offset+s,e,NN)]];                         n=elements->Nodes[INDEX2(dof_offset+s,e,NN)];
135                         data_array=getSampleData(data,n);                         data_array=getSampleData(data,n);
136                         for (q=0;q<jac->ReferenceElement->numQuadNodes;q++) {                         for (q=0;q<jac->ReferenceElement->numQuadNodes;q++) {
137                             for (l=0;l<numComps;l++) {                             for (l=0;l<numComps;l++) {
# Line 145  void Finley_Assemble_gradient(Finley_Nod Line 144  void Finley_Assemble_gradient(Finley_Nod
144                      }                      }
145                  }                  }
146                  #undef DIM                  #undef DIM
147           } else if (jac->numDim==3) {              } else if (jac->numDim==3) {
148                  #define DIM 3                  #define DIM 3
149                  #pragma omp for private(e,grad_data_e,s,n,data_array,q,l) schedule(static)                  #pragma omp for private(e,grad_data_e,s,n,data_array,q,l) schedule(static)
150              for (e=0;e<elements->numElements;e++) {              for (e=0;e<elements->numElements;e++) {
151                      grad_data_e=getSampleData(grad_data,e);                      grad_data_e=getSampleData(grad_data,e);
152                      for (q=0;q<DIM*(jac->ReferenceElement->numQuadNodes)*numComps; q++) grad_data_e[q]=0;                      for (q=0;q<DIM*(jac->ReferenceElement->numQuadNodes)*numComps; q++) grad_data_e[q]=0;
153                      for (s=0;s<jac->ReferenceElement->Type->numShapes;s++) {                      for (s=0;s<jac->ReferenceElement->Type->numShapes;s++) {
154                         n=mapping->target[elements->Nodes[INDEX2(dof_offset+s,e,NN)]];                         n=elements->Nodes[INDEX2(dof_offset+s,e,NN)];
155                         data_array=getSampleData(data,n);                         data_array=getSampleData(data,n);
156                         for (q=0;q<jac->ReferenceElement->numQuadNodes;q++) {                         for (q=0;q<jac->ReferenceElement->numQuadNodes;q++) {
157                             for (l=0;l<numComps;l++) {                             for (l=0;l<numComps;l++) {
# Line 167  void Finley_Assemble_gradient(Finley_Nod Line 166  void Finley_Assemble_gradient(Finley_Nod
166                      }                      }
167                  }                  }
168                  #undef DIM                  #undef DIM
169                }
170    
171             } else if (data_type==FINLEY_REDUCED_NODES) {
172                if (jac->numDim==1) {
173                    #define DIM 1
174                    #pragma omp for schedule(static)
175                for (e=0;e<elements->numElements;e++) {
176                        grad_data_e=getSampleData(grad_data,e);
177                        for (q=0;q<DIM*(jac->ReferenceElement->numQuadNodes)*numComps; q++) grad_data_e[q]=0;
178                        for (s=0;s<jac->ReferenceElement->Type->numShapes;s++) {
179                           n=elements->Nodes[INDEX2(elements->ReferenceElement->Type->linearNodes[dof_offset+s],e,NN)];
180                           data_array=getSampleData(data,nodes->reducedNodesMapping->target[n]);
181                           for (q=0;q<jac->ReferenceElement->numQuadNodes;q++) {
182                               for (l=0;l<numComps;l++) {
183                                   grad_data_e[INDEX3(l,0,q,numComps,DIM)]+=data_array[l]*
184                                            jac->DSDX[INDEX4(s_offset+s,0,q,e,jac->ReferenceElement->Type->numNodes,DIM,jac->ReferenceElement->numQuadNodes)];
185                               }
186                           }
187                        }
188                    }
189    
190                    #undef DIM
191                } else if (jac->numDim==2) {
192                    #define DIM 2
193                    #pragma omp for schedule(static)
194                for (e=0;e<elements->numElements;e++) {
195                        grad_data_e=getSampleData(grad_data,e);
196                        for (q=0;q<DIM*(jac->ReferenceElement->numQuadNodes)*numComps; q++) grad_data_e[q]=0;
197                        for (s=0;s<jac->ReferenceElement->Type->numShapes;s++) {
198                           n=elements->Nodes[INDEX2(elements->ReferenceElement->Type->linearNodes[dof_offset+s],e,NN)];
199                           data_array=getSampleData(data,nodes->reducedNodesMapping->target[n]);
200                           for (q=0;q<jac->ReferenceElement->numQuadNodes;q++) {
201                               for (l=0;l<numComps;l++) {
202                                   grad_data_e[INDEX3(l,0,q,numComps,DIM)]+=data_array[l]*
203                                         jac->DSDX[INDEX4(s_offset+s,0,q,e,jac->ReferenceElement->Type->numNodes,DIM,jac->ReferenceElement->numQuadNodes)];
204                                   grad_data_e[INDEX3(l,1,q,numComps,DIM)]+=data_array[l]*
205                                         jac->DSDX[INDEX4(s_offset+s,1,q,e,jac->ReferenceElement->Type->numNodes,DIM,jac->ReferenceElement->numQuadNodes)];
206                               }
207                           }
208                        }
209                    }
210    
211                    #undef DIM
212    
213                } else if (jac->numDim==3) {
214                    #define DIM 3
215                    #pragma omp for schedule(static)
216                for (e=0;e<elements->numElements;e++) {
217                        grad_data_e=getSampleData(grad_data,e);
218                        for (q=0;q<DIM*(jac->ReferenceElement->numQuadNodes)*numComps; q++) grad_data_e[q]=0;
219                        for (s=0;s<jac->ReferenceElement->Type->numShapes;s++) {
220                           n=elements->Nodes[INDEX2(elements->ReferenceElement->Type->linearNodes[dof_offset+s],e,NN)];
221                           data_array=getSampleData(data,nodes->reducedNodesMapping->target[n]);
222                           for (q=0;q<jac->ReferenceElement->numQuadNodes;q++) {
223                               for (l=0;l<numComps;l++) {
224                                   grad_data_e[INDEX3(l,0,q,numComps,DIM)]+=data_array[l]*
225                                            jac->DSDX[INDEX4(s_offset+s,0,q,e,jac->ReferenceElement->Type->numNodes,DIM,jac->ReferenceElement->numQuadNodes)];
226                                   grad_data_e[INDEX3(l,1,q,numComps,DIM)]+=data_array[l]*
227                                            jac->DSDX[INDEX4(s_offset+s,1,q,e,jac->ReferenceElement->Type->numNodes,DIM,jac->ReferenceElement->numQuadNodes)];
228                                   grad_data_e[INDEX3(l,2,q,numComps,DIM)]+=data_array[l]*
229                                            jac->DSDX[INDEX4(s_offset+s,2,q,e,jac->ReferenceElement->Type->numNodes,DIM,jac->ReferenceElement->numQuadNodes)];
230                               }
231                           }
232                        }
233                    }
234                    #undef DIM
235                }
236             } else if (data_type==FINLEY_DEGREES_OF_FREEDOM) {
237    
238                if (jac->numDim==1) {
239                    #define DIM 1
240                    #pragma omp for schedule(static)
241                for (e=0;e<elements->numElements;e++) {
242                        grad_data_e=getSampleData(grad_data,e);
243                        for (q=0;q<DIM*(jac->ReferenceElement->numQuadNodes)*numComps; q++) grad_data_e[q]=0;
244                        for (s=0;s<jac->ReferenceElement->Type->numShapes;s++) {
245                           n=elements->Nodes[INDEX2(dof_offset+s,e,NN)];
246                           data_array=getSampleData(data,nodes->degreesOfFreedomMapping->target[n]);
247                           for (q=0;q<jac->ReferenceElement->numQuadNodes;q++) {
248                               for (l=0;l<numComps;l++) {
249                                   grad_data_e[INDEX3(l,0,q,numComps,DIM)]+=data_array[l]*
250                                            jac->DSDX[INDEX4(s_offset+s,0,q,e,jac->ReferenceElement->Type->numNodes,DIM,jac->ReferenceElement->numQuadNodes)];
251                               }
252                           }
253                        }
254                    }
255    
256                    #undef DIM
257                } else if (jac->numDim==2) {
258                    #define DIM 2
259                    #pragma omp for schedule(static)
260                for (e=0;e<elements->numElements;e++) {
261                        grad_data_e=getSampleData(grad_data,e);
262                        for (q=0;q<DIM*(jac->ReferenceElement->numQuadNodes)*numComps; q++) grad_data_e[q]=0;
263                        for (s=0;s<jac->ReferenceElement->Type->numShapes;s++) {
264                           n=elements->Nodes[INDEX2(dof_offset+s,e,NN)];
265                           data_array=getSampleData(data,nodes->degreesOfFreedomMapping->target[n]);
266                           for (q=0;q<jac->ReferenceElement->numQuadNodes;q++) {
267                               for (l=0;l<numComps;l++) {
268                                       grad_data_e[INDEX3(l,0,q,numComps,DIM)]+=data_array[l]*
269                                            jac->DSDX[INDEX4(s_offset+s,0,q,e,jac->ReferenceElement->Type->numNodes,DIM,jac->ReferenceElement->numQuadNodes)];
270                                       grad_data_e[INDEX3(l,1,q,numComps,DIM)]+=data_array[l]*
271                                            jac->DSDX[INDEX4(s_offset+s,1,q,e,jac->ReferenceElement->Type->numNodes,DIM,jac->ReferenceElement->numQuadNodes)];
272                               }
273                           }
274                        }
275                    }
276                    #undef DIM
277                } else if (jac->numDim==3) {
278                    #define DIM 3
279                    #pragma omp for schedule(static)
280                for (e=0;e<elements->numElements;e++) {
281                        grad_data_e=getSampleData(grad_data,e);
282                        for (q=0;q<DIM*(jac->ReferenceElement->numQuadNodes)*numComps; q++) grad_data_e[q]=0;
283                        for (s=0;s<jac->ReferenceElement->Type->numShapes;s++) {
284                           n=elements->Nodes[INDEX2(dof_offset+s,e,NN)];
285                           data_array=getSampleData(data,nodes->degreesOfFreedomMapping->target[n]);
286                           for (q=0;q<jac->ReferenceElement->numQuadNodes;q++) {
287                               for (l=0;l<numComps;l++) {
288                                   grad_data_e[INDEX3(l,0,q,numComps,DIM)]+=data_array[l]*
289                                        jac->DSDX[INDEX4(s_offset+s,0,q,e,jac->ReferenceElement->Type->numNodes,DIM,jac->ReferenceElement->numQuadNodes)];
290                                   grad_data_e[INDEX3(l,1,q,numComps,DIM)]+=data_array[l]*
291                                        jac->DSDX[INDEX4(s_offset+s,1,q,e,jac->ReferenceElement->Type->numNodes,DIM,jac->ReferenceElement->numQuadNodes)];
292                                   grad_data_e[INDEX3(l,2,q,numComps,DIM)]+=data_array[l]*
293                                        jac->DSDX[INDEX4(s_offset+s,2,q,e,jac->ReferenceElement->Type->numNodes,DIM,jac->ReferenceElement->numQuadNodes)];
294                               }
295                           }
296                        }
297                    }
298                    #undef DIM
299                }
300             } else if (data_type==FINLEY_REDUCED_DEGREES_OF_FREEDOM) {
301                if (jac->numDim==1) {
302                    #define DIM 1
303                    #pragma omp for schedule(static)
304                for (e=0;e<elements->numElements;e++) {
305                        grad_data_e=getSampleData(grad_data,e);
306                        for (q=0;q<DIM*(jac->ReferenceElement->numQuadNodes)*numComps; q++) grad_data_e[q]=0;
307                        for (s=0;s<jac->ReferenceElement->Type->numShapes;s++) {
308                           n=elements->Nodes[INDEX2(elements->ReferenceElement->Type->linearNodes[dof_offset+s],e,NN)];
309                           data_array=getSampleData(data,nodes->reducedDegreesOfFreedomMapping->target[n]);
310                           for (q=0;q<jac->ReferenceElement->numQuadNodes;q++) {
311                               for (l=0;l<numComps;l++) {
312                                   grad_data_e[INDEX3(l,0,q,numComps,DIM)]+=data_array[l]*
313                                            jac->DSDX[INDEX4(s_offset+s,0,q,e,jac->ReferenceElement->Type->numNodes,DIM,jac->ReferenceElement->numQuadNodes)];
314                               }
315                           }
316                        }
317                    }
318    
319                    #undef DIM
320                } else if (jac->numDim==2) {
321                    #define DIM 2
322                    #pragma omp for schedule(static)
323                for (e=0;e<elements->numElements;e++) {
324                        grad_data_e=getSampleData(grad_data,e);
325                        for (q=0;q<DIM*(jac->ReferenceElement->numQuadNodes)*numComps; q++) grad_data_e[q]=0;
326                        for (s=0;s<jac->ReferenceElement->Type->numShapes;s++) {
327                           n=elements->Nodes[INDEX2(elements->ReferenceElement->Type->linearNodes[dof_offset+s],e,NN)];
328                           data_array=getSampleData(data,nodes->reducedDegreesOfFreedomMapping->target[n]);
329                           for (q=0;q<jac->ReferenceElement->numQuadNodes;q++) {
330                               for (l=0;l<numComps;l++) {
331                                   grad_data_e[INDEX3(l,0,q,numComps,DIM)]+=data_array[l]*
332                                         jac->DSDX[INDEX4(s_offset+s,0,q,e,jac->ReferenceElement->Type->numNodes,DIM,jac->ReferenceElement->numQuadNodes)];
333                                   grad_data_e[INDEX3(l,1,q,numComps,DIM)]+=data_array[l]*
334                                         jac->DSDX[INDEX4(s_offset+s,1,q,e,jac->ReferenceElement->Type->numNodes,DIM,jac->ReferenceElement->numQuadNodes)];
335                               }
336                           }
337                        }
338                    }
339    
340                    #undef DIM
341    
342                } else if (jac->numDim==3) {
343                    #define DIM 3
344                    #pragma omp for schedule(static)
345                for (e=0;e<elements->numElements;e++) {
346                        grad_data_e=getSampleData(grad_data,e);
347                        for (q=0;q<DIM*(jac->ReferenceElement->numQuadNodes)*numComps; q++) grad_data_e[q]=0;
348                        for (s=0;s<jac->ReferenceElement->Type->numShapes;s++) {
349                           n=elements->Nodes[INDEX2(elements->ReferenceElement->Type->linearNodes[dof_offset+s],e,NN)];
350                           data_array=getSampleData(data,nodes->reducedDegreesOfFreedomMapping->target[n]);
351                           for (q=0;q<jac->ReferenceElement->numQuadNodes;q++) {
352                               for (l=0;l<numComps;l++) {
353                                   grad_data_e[INDEX3(l,0,q,numComps,DIM)]+=data_array[l]*
354                                            jac->DSDX[INDEX4(s_offset+s,0,q,e,jac->ReferenceElement->Type->numNodes,DIM,jac->ReferenceElement->numQuadNodes)];
355                                   grad_data_e[INDEX3(l,1,q,numComps,DIM)]+=data_array[l]*
356                                            jac->DSDX[INDEX4(s_offset+s,1,q,e,jac->ReferenceElement->Type->numNodes,DIM,jac->ReferenceElement->numQuadNodes)];
357                                   grad_data_e[INDEX3(l,2,q,numComps,DIM)]+=data_array[l]*
358                                            jac->DSDX[INDEX4(s_offset+s,2,q,e,jac->ReferenceElement->Type->numNodes,DIM,jac->ReferenceElement->numQuadNodes)];
359                               }
360                           }
361                        }
362                    }
363                    #undef DIM
364                }
365           }           }
366        } /* end parallel region */        } /* end parallel region */
367    }    }

Legend:
Removed from v.1270  
changed lines
  Added in v.1271

  ViewVC Help
Powered by ViewVC 1.1.26