/[escript]/branches/arrexp_2137_win_merge/finley/src/Assemble_CopyNodalData.c
ViewVC logotype

Diff of /branches/arrexp_2137_win_merge/finley/src/Assemble_CopyNodalData.c

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

revision 2221 by jfenwick, Wed Jan 14 00:23:39 2009 UTC revision 2222 by jfenwick, Tue Jan 20 04:52:39 2009 UTC
# Line 99  void Finley_Assemble_CopyNodalData(Finle Line 99  void Finley_Assemble_CopyNodalData(Finle
99          /*********************** FINLEY_NODES **************************************************/          /*********************** FINLEY_NODES **************************************************/
100          numComps_size=(size_t)numComps*sizeof(double);          numComps_size=(size_t)numComps*sizeof(double);
101          if (in_data_type == FINLEY_NODES) {          if (in_data_type == FINLEY_NODES) {
102           requireWrite(out);
103             if  (out_data_type == FINLEY_NODES) {             if  (out_data_type == FINLEY_NODES) {
104                #pragma omp parallel for private(n) schedule(static)            #pragma omp parallel private(n)
105                for (n=0;n<nodes->nodesMapping->numNodes;n++) {            {
106                     memcpy(getSampleDataFast(out,n), getSampleDataFast(in,n), numComps_size);          void* buff=allocSampleBuffer(in);
107                }              #pragma omp parallel for private(n) schedule(static)
108                    for (n=0;n<nodes->nodesMapping->numNodes;n++) {
109                       memcpy(getSampleDataRWFast(out,n), getSampleDataROFast(in,n,buff), numComps_size);
110                    }
111            freeSampleBuffer(buff);
112              }
113    
114             } else if (out_data_type == FINLEY_REDUCED_NODES) {             } else if (out_data_type == FINLEY_REDUCED_NODES) {
115                #pragma omp parallel for private(n) schedule(static)            #pragma omp parallel private(n)
116                for (n=0;n<nodes->reducedNodesMapping->numTargets;n++) {            {
117                     memcpy(getSampleDataFast(out,n),          void* buff=allocSampleBuffer(in);
118                            getSampleDataFast(in,nodes->reducedNodesMapping->map[n]),              #pragma omp for schedule(static)
119                    for (n=0;n<nodes->reducedNodesMapping->numTargets;n++) {
120                       memcpy(getSampleDataRWFast(out,n),
121                              getSampleDataROFast(in,nodes->reducedNodesMapping->map[n],buff),
122                            numComps_size);                            numComps_size);
123            }
124            freeSampleBuffer(buff);
125                }                }
126             } else if (out_data_type == FINLEY_DEGREES_OF_FREEDOM) {             } else if (out_data_type == FINLEY_DEGREES_OF_FREEDOM) {
127            int nComps = Paso_Distribution_getMyNumComponents(nodes->degreesOfFreedomDistribution);            int nComps = Paso_Distribution_getMyNumComponents(nodes->degreesOfFreedomDistribution);
128                #pragma omp parallel for private(n) schedule(static)            #pragma omp parallel private(n)
129                for (n=0;n<nComps;n++) {            {
130                     memcpy(getSampleDataFast(out,n),          void* buff=allocSampleBuffer(in);
131                            getSampleDataFast(in,nodes->degreesOfFreedomMapping->map[n]),              #pragma omp for schedule(static)
132                    for (n=0;n<nComps;n++) {
133                       memcpy(getSampleDataRWFast(out,n),
134                              getSampleDataROFast(in,nodes->degreesOfFreedomMapping->map[n],buff),
135                            numComps_size);                            numComps_size);
136            }
137            freeSampleBuffer(buff);
138                }                }
139    
140             } else if (out_data_type == FINLEY_REDUCED_DEGREES_OF_FREEDOM) {             } else if (out_data_type == FINLEY_REDUCED_DEGREES_OF_FREEDOM) {
141            int nComps = Paso_Distribution_getMyNumComponents(nodes->reducedDegreesOfFreedomDistribution);            int nComps = Paso_Distribution_getMyNumComponents(nodes->reducedDegreesOfFreedomDistribution);
142                #pragma omp parallel for private(n) schedule(static)            #pragma omp parallel private(n)
143                for (n=0;n<nComps;n++) {            {
144                     memcpy(getSampleDataFast(out,n),          void* buff=allocSampleBuffer(in);
145                            getSampleDataFast(in,nodes->reducedDegreesOfFreedomMapping->map[n]),              #pragma omp parallel for private(n) schedule(static)
146                    for (n=0;n<nComps;n++) {
147                       memcpy(getSampleDataRWFast(out,n),
148                              getSampleDataROFast(in,nodes->reducedDegreesOfFreedomMapping->map[n],buff),
149                            numComps_size);                            numComps_size);
150            }
151            freeSampleBuffer(buff);
152                }                }
153             }             }
154          /*********************** FINLEY_REDUCED_NODES **************************************************/          /*********************** FINLEY_REDUCED_NODES **************************************************/
155          } else if (in_data_type == FINLEY_REDUCED_NODES) {          } else if (in_data_type == FINLEY_REDUCED_NODES) {
156           requireWrite(out);
157             if  (out_data_type == FINLEY_NODES) {             if  (out_data_type == FINLEY_NODES) {
158               Finley_setError(TYPE_ERROR,"Finley_Assemble_CopyNodalData: cannot copy from reduced nodes to nodes.");               Finley_setError(TYPE_ERROR,"Finley_Assemble_CopyNodalData: cannot copy from reduced nodes to nodes.");
159    
160             } else if (out_data_type == FINLEY_REDUCED_NODES) {             } else if (out_data_type == FINLEY_REDUCED_NODES) {
161                #pragma omp parallel for private(n) schedule(static)            #pragma omp parallel private(n)
162                for (n=0;n<nodes->reducedNodesMapping->numNodes;n++) {            {
163                     memcpy(getSampleDataFast(out,n),getSampleDataFast(in,n),numComps_size);          void* buff=allocSampleBuffer(in);
164                #pragma omp for schedule(static)
165                    for (n=0;n<nodes->reducedNodesMapping->numNodes;n++) {
166                       memcpy(getSampleDataRWFast(out,n),getSampleDataROFast(in,n,buff),numComps_size);
167            }
168            freeSampleBuffer(buff);
169                }                }
170    
171             } else if (out_data_type == FINLEY_DEGREES_OF_FREEDOM) {             } else if (out_data_type == FINLEY_DEGREES_OF_FREEDOM) {
172               Finley_setError(TYPE_ERROR,"Finley_Assemble_CopyNodalData: cannot copy from reduced nodes to degrees of freedom.");               Finley_setError(TYPE_ERROR,"Finley_Assemble_CopyNodalData: cannot copy from reduced nodes to degrees of freedom.");
173             } else if (out_data_type == FINLEY_REDUCED_DEGREES_OF_FREEDOM) {             } else if (out_data_type == FINLEY_REDUCED_DEGREES_OF_FREEDOM) {
174            int nComps = Paso_Distribution_getMyNumComponents(nodes->reducedDegreesOfFreedomDistribution);            int nComps = Paso_Distribution_getMyNumComponents(nodes->reducedDegreesOfFreedomDistribution);
175                #pragma omp parallel for private(n,k) schedule(static)            #pragma omp parallel private(n)
176                for (n=0;n<nComps;n++) {            {
177            void* buff=allocSampleBuffer(in);
178                #pragma omp for schedule(static)
179                    for (n=0;n<nComps;n++) {
180                     k=nodes->reducedDegreesOfFreedomMapping->map[n];                     k=nodes->reducedDegreesOfFreedomMapping->map[n];
181                     memcpy(getSampleDataFast(out,n),                     memcpy(getSampleDataRWFast(out,n),
182                            getSampleDataFast(in,nodes->reducedNodesMapping->target[k]),                            getSampleDataROFast(in,nodes->reducedNodesMapping->target[k],buff),
183                            numComps_size);                            numComps_size);
184            }
185            freeSampleBuffer(buff);
186                }                }
187             }             }
188    
189          /*********************** FINLEY_DEGREES_OF_FREEDOM **************************************************/          /*********************** FINLEY_DEGREES_OF_FREEDOM **************************************************/
190          } else if (in_data_type == FINLEY_DEGREES_OF_FREEDOM) {          } else if (in_data_type == FINLEY_DEGREES_OF_FREEDOM) {
191            requireWrite(out);
192              if  (out_data_type == FINLEY_NODES) {              if  (out_data_type == FINLEY_NODES) {
193                 coupler=Paso_Coupler_alloc(nodes->degreesOfFreedomConnector,numComps);                 coupler=Paso_Coupler_alloc(nodes->degreesOfFreedomConnector,numComps);
194                 if (Paso_noError()) {                 if (Paso_noError()) {
195                      Paso_Coupler_startCollect(coupler,getSampleDataFast(in,0));              /* It is not immediately clear whether coupler can be trusted with constant data so I'll assume RW */
196                /* Also, it holds pointers so it might not be safe to use on lazy data anyway?*/
197                requireWrite(in);
198                        Paso_Coupler_startCollect(coupler,getSampleDataRWFast(in,0));
199                      recv_buffer=Paso_Coupler_finishCollect(coupler);                      recv_buffer=Paso_Coupler_finishCollect(coupler);
200                      upperBound=Paso_Distribution_getMyNumComponents(nodes->degreesOfFreedomDistribution);                      upperBound=Paso_Distribution_getMyNumComponents(nodes->degreesOfFreedomDistribution);
201                      #pragma omp parallel for private(n,k) schedule(static)              #pragma omp parallel private(n,k)
202                      for (n=0;n<nodes->numNodes;n++) {              {
203                void* buff=allocSampleBuffer(in);
204                #pragma omp for schedule(static)
205                            for (n=0;n<nodes->numNodes;n++) {
206                            k=nodes->degreesOfFreedomMapping->target[n];                            k=nodes->degreesOfFreedomMapping->target[n];
207                            if (k < upperBound) {                            if (k < upperBound) {
208                                  memcpy(getSampleDataFast(out,n),                                  memcpy(getSampleDataRWFast(out,n),
209                                         getSampleDataFast(in,k),                                         getSampleDataROFast(in,k,buff),
210                                         numComps_size);                                         numComps_size);
211                             } else {                             } else {
212                                  memcpy(getSampleDataFast(out,n),                                  memcpy(getSampleDataRWFast(out,n),
213                                         &recv_buffer[(k-upperBound)*numComps],                                         &recv_buffer[(k-upperBound)*numComps],
214                                         numComps_size);                                         numComps_size);
215                             }                             }
216                      }                          }
217                freeSampleBuffer(buff);
218                }
219                 }                 }
220                 Paso_Coupler_free(coupler);                 Paso_Coupler_free(coupler);
221              } else if  (out_data_type == FINLEY_REDUCED_NODES) {              } else if  (out_data_type == FINLEY_REDUCED_NODES) {
222                 coupler=Paso_Coupler_alloc(nodes->degreesOfFreedomConnector,numComps);                 coupler=Paso_Coupler_alloc(nodes->degreesOfFreedomConnector,numComps);
223                 if (Paso_noError()) {                 if (Paso_noError()) {
224                      Paso_Coupler_startCollect(coupler,getSampleDataFast(in,0));              requireWrite(in);   /* See comment above about coupler and const */
225                        Paso_Coupler_startCollect(coupler,getSampleDataRWFast(in,0));
226                      recv_buffer=Paso_Coupler_finishCollect(coupler);                      recv_buffer=Paso_Coupler_finishCollect(coupler);
227                      upperBound=Paso_Distribution_getMyNumComponents(nodes->degreesOfFreedomDistribution);                      upperBound=Paso_Distribution_getMyNumComponents(nodes->degreesOfFreedomDistribution);
228                      #pragma omp parallel for private(n,k,l) schedule(static)              requireWrite(out);
229                      for (n=0;n<nodes->reducedNodesMapping->numTargets;n++) {              #pragma omp parallel private(n,k,l)
230                {
231                void* buff=allocSampleBuffer(in);
232                #pragma omp for schedule(static)
233                            for (n=0;n<nodes->reducedNodesMapping->numTargets;n++) {
234                            l=nodes->reducedNodesMapping->map[n];                            l=nodes->reducedNodesMapping->map[n];
235                            k=nodes->degreesOfFreedomMapping->target[l];                            k=nodes->degreesOfFreedomMapping->target[l];
236                            if (k < upperBound) {                            if (k < upperBound) {
237                                  memcpy(getSampleDataFast(out,n),                                  memcpy(getSampleDataRWFast(out,n),
238                                         getSampleDataFast(in,k),                                         getSampleDataROFast(in,k,buff),
239                                         numComps_size);                                         numComps_size);
240                             } else {                             } else {
241                                  memcpy(getSampleDataFast(out,n),                                  memcpy(getSampleDataRWFast(out,n),
242                                         &recv_buffer[(k-upperBound)*numComps],                                         &recv_buffer[(k-upperBound)*numComps],
243                                         numComps_size);                                         numComps_size);
244                             }                             }
245                      }                          }
246                freeSampleBuffer(buff);
247                }
248                 }                 }
249                 Paso_Coupler_free(coupler);                 Paso_Coupler_free(coupler);
250             } else if (out_data_type == FINLEY_DEGREES_OF_FREEDOM) {             } else if (out_data_type == FINLEY_DEGREES_OF_FREEDOM) {
251            int nComps = Paso_Distribution_getMyNumComponents(nodes->degreesOfFreedomDistribution);            int nComps = Paso_Distribution_getMyNumComponents(nodes->degreesOfFreedomDistribution);
252                #pragma omp parallel for private(n) schedule(static)            requireWrite(out);
253                for (n=0;n<nComps;n++) {            #pragma omp parallel private(n)
254                      memcpy(getSampleDataFast(out,n),getSampleDataFast(in,n),numComps_size);            {
255                }          void* buff=allocSampleBuffer(in);
256            #pragma omp for schedule(static)
257                    for (n=0;n<nComps;n++) {
258                        memcpy(getSampleDataRWFast(out,n),getSampleDataROFast(in,n,buff),numComps_size);
259                    }
260            freeSampleBuffer(buff);
261              }
262    
263             } else if (out_data_type == FINLEY_REDUCED_DEGREES_OF_FREEDOM) {             } else if (out_data_type == FINLEY_REDUCED_DEGREES_OF_FREEDOM) {
264            int nComps = Paso_Distribution_getMyNumComponents(nodes->reducedDegreesOfFreedomDistribution);            int nComps = Paso_Distribution_getMyNumComponents(nodes->reducedDegreesOfFreedomDistribution);
265                #pragma omp parallel for private(n,k) schedule(static)            requireWrite(out);
266                for (n=0;n<nComps;n++) {            #pragma omp parallel private(n,k)
267              {
268            void* buff=allocSampleBuffer(in);
269            #pragma omp for schedule(static)
270                    for (n=0;n<nComps;n++) {
271                     k=nodes->reducedDegreesOfFreedomMapping->map[n];                     k=nodes->reducedDegreesOfFreedomMapping->map[n];
272                     memcpy(getSampleDataFast(out,n),                     memcpy(getSampleDataRWFast(out,n),
273                            getSampleDataFast(in,nodes->degreesOfFreedomMapping->target[k]),                            getSampleDataROFast(in,nodes->degreesOfFreedomMapping->target[k],buff),
274                            numComps_size);                            numComps_size);
275                }                  }
276            freeSampleBuffer(buff);
277              }
278             }             }
279    
280          } else if (in_data_type == FINLEY_REDUCED_DEGREES_OF_FREEDOM) {          } else if (in_data_type == FINLEY_REDUCED_DEGREES_OF_FREEDOM) {
# Line 228  void Finley_Assemble_CopyNodalData(Finle Line 285  void Finley_Assemble_CopyNodalData(Finle
285                 coupler=Paso_Coupler_alloc(nodes->reducedDegreesOfFreedomConnector,numComps);                 coupler=Paso_Coupler_alloc(nodes->reducedDegreesOfFreedomConnector,numComps);
286                 if (Paso_noError()) {                 if (Paso_noError()) {
287                      upperBound=Paso_Distribution_getMyNumComponents(nodes->reducedDegreesOfFreedomDistribution);                      upperBound=Paso_Distribution_getMyNumComponents(nodes->reducedDegreesOfFreedomDistribution);
288                      Paso_Coupler_startCollect(coupler,getSampleDataFast(in,0));              requireWrite(in);           /* See comment about coupler and const */
289                        Paso_Coupler_startCollect(coupler,getSampleDataRWFast(in,0));
290                      recv_buffer=Paso_Coupler_finishCollect(coupler);                      recv_buffer=Paso_Coupler_finishCollect(coupler);
291                      #pragma omp parallel for private(n,k,l) schedule(static)              requireWrite(out);
292                      for (n=0;n<nodes->reducedNodesMapping->numTargets;n++) {              #pragma omp parallel private(n,k,l)
293                {
294                void* buff=allocSampleBuffer(in);
295                #pragma omp for schedule(static)
296                            for (n=0;n<nodes->reducedNodesMapping->numTargets;n++) {
297                            l=nodes->reducedNodesMapping->map[n];                            l=nodes->reducedNodesMapping->map[n];
298                            k=nodes->reducedDegreesOfFreedomMapping->target[l];                            k=nodes->reducedDegreesOfFreedomMapping->target[l];
299                            if (k < upperBound) {                            if (k < upperBound) {
300                                  memcpy(getSampleDataFast(out,n),                                  memcpy(getSampleDataRWFast(out,n),
301                                         getSampleDataFast(in,k),                                         getSampleDataROFast(in,k,buff),
302                                         numComps_size);                                         numComps_size);
303                             } else {                             } else {
304                                  memcpy(getSampleDataFast(out,n),                                  memcpy(getSampleDataRWFast(out,n),
305                                         &recv_buffer[(k-upperBound)*numComps],                                         &recv_buffer[(k-upperBound)*numComps],
306                                         numComps_size);                                         numComps_size);
307                             }                             }
308                      }                          }
309                freeSampleBuffer(buff);
310                }
311                 }                 }
312                 Paso_Coupler_free(coupler);                 Paso_Coupler_free(coupler);
313             } else if (out_data_type == FINLEY_REDUCED_DEGREES_OF_FREEDOM) {             } else if (out_data_type == FINLEY_REDUCED_DEGREES_OF_FREEDOM) {
314            int nComps = Paso_Distribution_getMyNumComponents(nodes->reducedDegreesOfFreedomDistribution);            int nComps = Paso_Distribution_getMyNumComponents(nodes->reducedDegreesOfFreedomDistribution);
315                #pragma omp parallel for private(n) schedule(static)            requireWrite(out);
316                for (n=0;n<nComps;n++) {            #pragma omp parallel private(n)
317                      memcpy(getSampleDataFast(out,n),getSampleDataFast(in,n),numComps_size);            {
318                }          void* buff=allocSampleBuffer(in);
319            #pragma omp for schedule(static)
320                    for (n=0;n<nComps;n++) {
321                        memcpy(getSampleDataRWFast(out,n),getSampleDataROFast(in,n,buff),numComps_size);
322                    }
323              }
324             } else if (out_data_type == FINLEY_DEGREES_OF_FREEDOM ) {             } else if (out_data_type == FINLEY_DEGREES_OF_FREEDOM ) {
325               Finley_setError(TYPE_ERROR,"Finley_Assemble_CopyNodalData: cannot copy from reduced degrees of freedom to degrees of freedom.");               Finley_setError(TYPE_ERROR,"Finley_Assemble_CopyNodalData: cannot copy from reduced degrees of freedom to degrees of freedom.");
326             }             }

Legend:
Removed from v.2221  
changed lines
  Added in v.2222

  ViewVC Help
Powered by ViewVC 1.1.26