/[escript]/trunk/dudley/src/Assemble_CopyNodalData.cpp
ViewVC logotype

Diff of /trunk/dudley/src/Assemble_CopyNodalData.cpp

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

revision 2270 by ksteube, Thu Sep 25 23:11:13 2008 UTC revision 2271 by jfenwick, Mon Feb 16 05:08:29 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)            void* buff=allocSampleBuffer(in);
105                for (n=0;n<nodes->nodesMapping->numNodes;n++) {            #pragma omp parallel private(n)
106                     memcpy(getSampleDataFast(out,n), getSampleDataFast(in,n), numComps_size);            {
107                }  
108                #pragma omp parallel for private(n) schedule(static)
109                    for (n=0;n<nodes->nodesMapping->numNodes;n++) {
110                       memcpy(getSampleDataRWFast(out,n), getSampleDataROFast(in,n,buff), numComps_size);
111                    }
112              }
113              freeSampleBuffer(buff);
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)            void* buff=allocSampleBuffer(in);
116                for (n=0;n<nodes->reducedNodesMapping->numTargets;n++) {            #pragma omp parallel private(n)
117                     memcpy(getSampleDataFast(out,n),            {
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                }                }
125              freeSampleBuffer(buff);
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)            void* buff=allocSampleBuffer(in);
129                for (n=0;n<nComps;n++) {            #pragma omp parallel private(n)
130                     memcpy(getSampleDataFast(out,n),            {
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                }                }
138              freeSampleBuffer(buff);
139             } else if (out_data_type == FINLEY_REDUCED_DEGREES_OF_FREEDOM) {             } else if (out_data_type == FINLEY_REDUCED_DEGREES_OF_FREEDOM) {
140            int nComps = Paso_Distribution_getMyNumComponents(nodes->reducedDegreesOfFreedomDistribution);            int nComps = Paso_Distribution_getMyNumComponents(nodes->reducedDegreesOfFreedomDistribution);
141                #pragma omp parallel for private(n) schedule(static)            void* buff=allocSampleBuffer(in);
142                for (n=0;n<nComps;n++) {            #pragma omp parallel private(n)
143                     memcpy(getSampleDataFast(out,n),            {
144                            getSampleDataFast(in,nodes->reducedDegreesOfFreedomMapping->map[n]),              #pragma omp for schedule(static)
145                    for (n=0;n<nComps;n++) {
146                       memcpy(getSampleDataRWFast(out,n),
147                              getSampleDataROFast(in,nodes->reducedDegreesOfFreedomMapping->map[n],buff),
148                            numComps_size);                            numComps_size);
149            }
150                }                }
151              freeSampleBuffer(buff);
152             }             }
153          /*********************** FINLEY_REDUCED_NODES **************************************************/          /*********************** FINLEY_REDUCED_NODES **************************************************/
154          } else if (in_data_type == FINLEY_REDUCED_NODES) {          } else if (in_data_type == FINLEY_REDUCED_NODES) {
155           requireWrite(out);
156             if  (out_data_type == FINLEY_NODES) {             if  (out_data_type == FINLEY_NODES) {
157               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.");
158    
159             } else if (out_data_type == FINLEY_REDUCED_NODES) {             } else if (out_data_type == FINLEY_REDUCED_NODES) {
160                #pragma omp parallel for private(n) schedule(static)            void* buff=allocSampleBuffer(in);
161                for (n=0;n<nodes->reducedNodesMapping->numNodes;n++) {            #pragma omp parallel private(n)
162                     memcpy(getSampleDataFast(out,n),getSampleDataFast(in,n),numComps_size);            {
163                #pragma omp for schedule(static)
164                    for (n=0;n<nodes->reducedNodesMapping->numNodes;n++) {
165                       memcpy(getSampleDataRWFast(out,n),getSampleDataROFast(in,n,buff),numComps_size);
166            }
167                }                }
168              freeSampleBuffer(buff);
169             } else if (out_data_type == FINLEY_DEGREES_OF_FREEDOM) {             } else if (out_data_type == FINLEY_DEGREES_OF_FREEDOM) {
170               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.");
171             } else if (out_data_type == FINLEY_REDUCED_DEGREES_OF_FREEDOM) {             } else if (out_data_type == FINLEY_REDUCED_DEGREES_OF_FREEDOM) {
172            int nComps = Paso_Distribution_getMyNumComponents(nodes->reducedDegreesOfFreedomDistribution);            int nComps = Paso_Distribution_getMyNumComponents(nodes->reducedDegreesOfFreedomDistribution);
173                #pragma omp parallel for private(n,k) schedule(static)            void* buff=allocSampleBuffer(in);
174                for (n=0;n<nComps;n++) {            #pragma omp parallel private(n,k)
175              {
176                #pragma omp for schedule(static)
177                    for (n=0;n<nComps;n++) {
178                     k=nodes->reducedDegreesOfFreedomMapping->map[n];                     k=nodes->reducedDegreesOfFreedomMapping->map[n];
179                     memcpy(getSampleDataFast(out,n),                     memcpy(getSampleDataRWFast(out,n),
180                            getSampleDataFast(in,nodes->reducedNodesMapping->target[k]),                            getSampleDataROFast(in,nodes->reducedNodesMapping->target[k],buff),
181                            numComps_size);                            numComps_size);
182            }
183                }                }
184              freeSampleBuffer(buff);
185             }             }
186    
187          /*********************** FINLEY_DEGREES_OF_FREEDOM **************************************************/          /*********************** FINLEY_DEGREES_OF_FREEDOM **************************************************/
188          } else if (in_data_type == FINLEY_DEGREES_OF_FREEDOM) {          } else if (in_data_type == FINLEY_DEGREES_OF_FREEDOM) {
189            requireWrite(out);
190              if  (out_data_type == FINLEY_NODES) {              if  (out_data_type == FINLEY_NODES) {
191                 coupler=Paso_Coupler_alloc(nodes->degreesOfFreedomConnector,numComps);                 coupler=Paso_Coupler_alloc(nodes->degreesOfFreedomConnector,numComps);
192                 if (Paso_noError()) {                 if (Paso_noError()) {
193                      Paso_Coupler_startCollect(coupler,getSampleDataFast(in,0));              void* buff=allocSampleBuffer(in);
194                /* It is not immediately clear whether coupler can be trusted with constant data so I'll assume RW */
195                /* Also, it holds pointers so it might not be safe to use on lazy data anyway?*/
196                requireWrite(in);
197                        Paso_Coupler_startCollect(coupler,getSampleDataRWFast(in,0));
198                      recv_buffer=Paso_Coupler_finishCollect(coupler);                      recv_buffer=Paso_Coupler_finishCollect(coupler);
199                      upperBound=Paso_Distribution_getMyNumComponents(nodes->degreesOfFreedomDistribution);                      upperBound=Paso_Distribution_getMyNumComponents(nodes->degreesOfFreedomDistribution);
200                      #pragma omp parallel for private(n,k) schedule(static)              #pragma omp parallel private(n,k)
201                      for (n=0;n<nodes->numNodes;n++) {              {
202                #pragma omp for schedule(static)
203                            for (n=0;n<nodes->numNodes;n++) {
204                            k=nodes->degreesOfFreedomMapping->target[n];                            k=nodes->degreesOfFreedomMapping->target[n];
205                            if (k < upperBound) {                            if (k < upperBound) {
206                                  memcpy(getSampleDataFast(out,n),                                  memcpy(getSampleDataRWFast(out,n),
207                                         getSampleDataFast(in,k),                                         getSampleDataROFast(in,k,buff),
208                                         numComps_size);                                         numComps_size);
209                             } else {                             } else {
210                                  memcpy(getSampleDataFast(out,n),                                  memcpy(getSampleDataRWFast(out,n),
211                                         &recv_buffer[(k-upperBound)*numComps],                                         &recv_buffer[(k-upperBound)*numComps],
212                                         numComps_size);                                         numComps_size);
213                             }                             }
214                      }                          }
215                }
216                freeSampleBuffer(buff);
217                 }                 }
218                 Paso_Coupler_free(coupler);                 Paso_Coupler_free(coupler);
219              } else if  (out_data_type == FINLEY_REDUCED_NODES) {              } else if  (out_data_type == FINLEY_REDUCED_NODES) {
220                 coupler=Paso_Coupler_alloc(nodes->degreesOfFreedomConnector,numComps);                 coupler=Paso_Coupler_alloc(nodes->degreesOfFreedomConnector,numComps);
221                 if (Paso_noError()) {                 if (Paso_noError()) {
222                      Paso_Coupler_startCollect(coupler,getSampleDataFast(in,0));              void* buff=allocSampleBuffer(in);
223                requireWrite(in);   /* See comment above about coupler and const */
224                        Paso_Coupler_startCollect(coupler,getSampleDataRWFast(in,0));
225                      recv_buffer=Paso_Coupler_finishCollect(coupler);                      recv_buffer=Paso_Coupler_finishCollect(coupler);
226                      upperBound=Paso_Distribution_getMyNumComponents(nodes->degreesOfFreedomDistribution);                      upperBound=Paso_Distribution_getMyNumComponents(nodes->degreesOfFreedomDistribution);
227                      #pragma omp parallel for private(n,k,l) schedule(static)              requireWrite(out);
228                      for (n=0;n<nodes->reducedNodesMapping->numTargets;n++) {  
229                #pragma omp parallel private(n,k,l)
230                {
231                #pragma omp for schedule(static)
232                            for (n=0;n<nodes->reducedNodesMapping->numTargets;n++) {
233                            l=nodes->reducedNodesMapping->map[n];                            l=nodes->reducedNodesMapping->map[n];
234                            k=nodes->degreesOfFreedomMapping->target[l];                            k=nodes->degreesOfFreedomMapping->target[l];
235                            if (k < upperBound) {                            if (k < upperBound) {
236                                  memcpy(getSampleDataFast(out,n),                                  memcpy(getSampleDataRWFast(out,n),
237                                         getSampleDataFast(in,k),                                         getSampleDataROFast(in,k,buff),
238                                         numComps_size);                                         numComps_size);
239                             } else {                             } else {
240                                  memcpy(getSampleDataFast(out,n),                                  memcpy(getSampleDataRWFast(out,n),
241                                         &recv_buffer[(k-upperBound)*numComps],                                         &recv_buffer[(k-upperBound)*numComps],
242                                         numComps_size);                                         numComps_size);
243                             }                             }
244                      }                          }
245                }
246                freeSampleBuffer(buff);
247                 }                 }
248                 Paso_Coupler_free(coupler);                 Paso_Coupler_free(coupler);
249             } else if (out_data_type == FINLEY_DEGREES_OF_FREEDOM) {             } else if (out_data_type == FINLEY_DEGREES_OF_FREEDOM) {
250              void* buff=allocSampleBuffer(in);
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                }          #pragma omp for schedule(static)
256                    for (n=0;n<nComps;n++) {
257                        memcpy(getSampleDataRWFast(out,n),getSampleDataROFast(in,n,buff),numComps_size);
258                    }
259              }
260              freeSampleBuffer(buff);
261             } else if (out_data_type == FINLEY_REDUCED_DEGREES_OF_FREEDOM) {             } else if (out_data_type == FINLEY_REDUCED_DEGREES_OF_FREEDOM) {
262              void* buff=allocSampleBuffer(in);
263            int nComps = Paso_Distribution_getMyNumComponents(nodes->reducedDegreesOfFreedomDistribution);            int nComps = Paso_Distribution_getMyNumComponents(nodes->reducedDegreesOfFreedomDistribution);
264                #pragma omp parallel for private(n,k) schedule(static)            requireWrite(out);
265                for (n=0;n<nComps;n++) {            #pragma omp parallel private(n,k)
266              {
267            #pragma omp for schedule(static)
268                    for (n=0;n<nComps;n++) {
269                     k=nodes->reducedDegreesOfFreedomMapping->map[n];                     k=nodes->reducedDegreesOfFreedomMapping->map[n];
270                     memcpy(getSampleDataFast(out,n),                     memcpy(getSampleDataRWFast(out,n),
271                            getSampleDataFast(in,nodes->degreesOfFreedomMapping->target[k]),                            getSampleDataROFast(in,nodes->degreesOfFreedomMapping->target[k],buff),
272                            numComps_size);                            numComps_size);
273                }                  }
274              }
275              freeSampleBuffer(buff);
276             }             }
277    
278          } else if (in_data_type == FINLEY_REDUCED_DEGREES_OF_FREEDOM) {          } else if (in_data_type == FINLEY_REDUCED_DEGREES_OF_FREEDOM) {
# Line 227  void Finley_Assemble_CopyNodalData(Finle Line 282  void Finley_Assemble_CopyNodalData(Finle
282             } else if (out_data_type == FINLEY_REDUCED_NODES) {             } else if (out_data_type == FINLEY_REDUCED_NODES) {
283                 coupler=Paso_Coupler_alloc(nodes->reducedDegreesOfFreedomConnector,numComps);                 coupler=Paso_Coupler_alloc(nodes->reducedDegreesOfFreedomConnector,numComps);
284                 if (Paso_noError()) {                 if (Paso_noError()) {
285                void* buff=allocSampleBuffer(in);
286                      upperBound=Paso_Distribution_getMyNumComponents(nodes->reducedDegreesOfFreedomDistribution);                      upperBound=Paso_Distribution_getMyNumComponents(nodes->reducedDegreesOfFreedomDistribution);
287                      Paso_Coupler_startCollect(coupler,getSampleDataFast(in,0));              requireWrite(in);           /* See comment about coupler and const */
288                        Paso_Coupler_startCollect(coupler,getSampleDataRWFast(in,0));
289                      recv_buffer=Paso_Coupler_finishCollect(coupler);                      recv_buffer=Paso_Coupler_finishCollect(coupler);
290                      #pragma omp parallel for private(n,k,l) schedule(static)              requireWrite(out);
291                      for (n=0;n<nodes->reducedNodesMapping->numTargets;n++) {              #pragma omp parallel private(n,k,l)
292                {
293                #pragma omp for schedule(static)
294                            for (n=0;n<nodes->reducedNodesMapping->numTargets;n++) {
295                            l=nodes->reducedNodesMapping->map[n];                            l=nodes->reducedNodesMapping->map[n];
296                            k=nodes->reducedDegreesOfFreedomMapping->target[l];                            k=nodes->reducedDegreesOfFreedomMapping->target[l];
297                            if (k < upperBound) {                            if (k < upperBound) {
298                                  memcpy(getSampleDataFast(out,n),                                  memcpy(getSampleDataRWFast(out,n),
299                                         getSampleDataFast(in,k),                                         getSampleDataROFast(in,k,buff),
300                                         numComps_size);                                         numComps_size);
301                             } else {                             } else {
302                                  memcpy(getSampleDataFast(out,n),                                  memcpy(getSampleDataRWFast(out,n),
303                                         &recv_buffer[(k-upperBound)*numComps],                                         &recv_buffer[(k-upperBound)*numComps],
304                                         numComps_size);                                         numComps_size);
305                             }                             }
306                      }                          }
307                }
308                freeSampleBuffer(buff);
309                 }                 }
310                 Paso_Coupler_free(coupler);                 Paso_Coupler_free(coupler);
311             } else if (out_data_type == FINLEY_REDUCED_DEGREES_OF_FREEDOM) {             } else if (out_data_type == FINLEY_REDUCED_DEGREES_OF_FREEDOM) {
312            int nComps = Paso_Distribution_getMyNumComponents(nodes->reducedDegreesOfFreedomDistribution);            int nComps = Paso_Distribution_getMyNumComponents(nodes->reducedDegreesOfFreedomDistribution);
313                #pragma omp parallel for private(n) schedule(static)            void* buff=allocSampleBuffer(in);
314                for (n=0;n<nComps;n++) {            requireWrite(out);
315                      memcpy(getSampleDataFast(out,n),getSampleDataFast(in,n),numComps_size);            #pragma omp parallel private(n)
316                }            {
317            #pragma omp for schedule(static)
318                    for (n=0;n<nComps;n++) {
319                        memcpy(getSampleDataRWFast(out,n),getSampleDataROFast(in,n,buff),numComps_size);
320                    }
321              }
322             } else if (out_data_type == FINLEY_DEGREES_OF_FREEDOM ) {             } else if (out_data_type == FINLEY_DEGREES_OF_FREEDOM ) {
323               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.");
324             }             }

Legend:
Removed from v.2270  
changed lines
  Added in v.2271

  ViewVC Help
Powered by ViewVC 1.1.26