/[escript]/branches/trilinos_from_5897/dudley/src/Assemble_CopyNodalData.cpp
ViewVC logotype

Diff of /branches/trilinos_from_5897/dudley/src/Assemble_CopyNodalData.cpp

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

revision 6008 by caltinay, Mon Feb 22 06:59:27 2016 UTC revision 6009 by caltinay, Wed Mar 2 04:13:26 2016 UTC
# Line 14  Line 14 
14  *  *
15  *****************************************************************************/  *****************************************************************************/
16    
17  /************************************************************************************/  /****************************************************************************
18    
19  /*    assemblage routines: copies data between different types nodal representation   */    Assemblage routines: copies data between different types nodal
20      representations
21    
22  /************************************************************************************/  *****************************************************************************/
   
 #define ESNEEDPYTHON  
 #include "esysUtils/first.h"  
23    
 #include "Util.h"  
24  #include "Assemble.h"  #include "Assemble.h"
25  #ifdef _OPENMP  #include "Util.h"
 #include <omp.h>  
 #endif  
26    
27  void Dudley_Assemble_CopyNodalData(Dudley_NodeFile * nodes, escript::Data * out, const escript::Data * in)  namespace dudley {
 {  
     dim_t n, k, l, mpiSize;  
     dim_t numComps = getDataPointSize(out);  
     paso::Coupler_ptr coupler;  
     int in_data_type = getFunctionSpaceType(in);  
     int out_data_type = getFunctionSpaceType(out);  
     index_t upperBound;  
     double *recv_buffer;  
     size_t numComps_size = 0;  
     Dudley_resetError();  
     if (nodes == NULL)  
     return;  
     mpiSize = nodes->MPIInfo->size;  
   
     /* check out and in */  
     if (numComps != getDataPointSize(in))  
     {  
     Dudley_setError(TYPE_ERROR,  
             "Dudley_Assemble_CopyNodalData: number of components of input and output Data do not match.");  
     }  
     else if (!isExpanded(out))  
     {  
     Dudley_setError(TYPE_ERROR, "Dudley_Assemble_CopyNodalData: expanded Data object is expected for output data.");  
     }  
28    
29      /* more sophisticated test needed for overlapping node/DOF counts */  void Assemble_CopyNodalData(Dudley_NodeFile* nodes, escript::Data* out, const escript::Data* in)
30      if (in_data_type == DUDLEY_NODES)  {
31      {      if (!nodes)
32      if (!numSamplesEqual(in, 1, Dudley_NodeFile_getNumNodes(nodes)))          return;
     {  
         Dudley_setError(TYPE_ERROR,  
                 "Dudley_Assemble_CopyNodalData: illegal number of samples of input Data object");  
     }  
     }  
     else if (in_data_type == DUDLEY_REDUCED_NODES)  
     {  
     if (!numSamplesEqual(in, 1, Dudley_NodeFile_getNumReducedNodes(nodes)))  
     {  
         Dudley_setError(TYPE_ERROR,  
                 "Dudley_Assemble_CopyNodalData: illegal number of samples of input Data object");  
     }  
     }  
     else if (in_data_type == DUDLEY_DEGREES_OF_FREEDOM)  
     {  
     if (!numSamplesEqual(in, 1, Dudley_NodeFile_getNumDegreesOfFreedom(nodes)))  
     {  
         Dudley_setError(TYPE_ERROR,  
                 "Dudley_Assemble_CopyNodalData: illegal number of samples of input Data object");  
     }  
     if ((((out_data_type == DUDLEY_NODES) || (out_data_type == DUDLEY_DEGREES_OF_FREEDOM)) && !isExpanded(in)  
          && (mpiSize > 1)))  
     {  
   
         Dudley_setError(TYPE_ERROR,  
                 "Dudley_Assemble_CopyNodalData: DUDLEY_DEGREES_OF_FREEDOM to DUDLEY_NODES or DUDLEY_DEGREES_OF_FREEDOM requires expanded input data on more than one processor.");  
     }  
     }  
     else if (in_data_type == DUDLEY_REDUCED_DEGREES_OF_FREEDOM)  
     {  
     if (!numSamplesEqual(in, 1, Dudley_NodeFile_getNumReducedDegreesOfFreedom(nodes)))  
     {  
         Dudley_setError(TYPE_ERROR,  
                 "Dudley_Assemble_CopyNodalData: illegal number of samples of input Data object");  
     }  
     if ((out_data_type == DUDLEY_DEGREES_OF_FREEDOM) && !isExpanded(in) && (mpiSize > 1))  
     {  
   
         Dudley_setError(TYPE_ERROR,  
                 "Dudley_Assemble_CopyNodalData: DUDLEY_REDUCED_DEGREES_OF_FREEDOM to DUDLEY_DEGREES_OF_FREEDOM requires expanded input data on more than one processor.");  
     }  
     }  
     else  
     {  
     Dudley_setError(TYPE_ERROR, "Dudley_Assemble_CopyNodalData: illegal function space type for target object");  
     }  
33    
34      if (out_data_type == DUDLEY_NODES)      const int mpiSize = nodes->MPIInfo->size;
35      {      const int numComps = out->getDataPointSize();
36      if (!numSamplesEqual(out, 1, Dudley_NodeFile_getNumNodes(nodes)))      const int in_data_type = in->getFunctionSpace().getTypeCode();
37      {      const int out_data_type = out->getFunctionSpace().getTypeCode();
38          Dudley_setError(TYPE_ERROR,  
39                  "Dudley_Assemble_CopyNodalData: illegal number of samples of output Data object");      // check out and in
40      }      if (numComps != in->getDataPointSize()) {
41      }          throw DudleyException("Assemble_CopyNodalData: number of components of input and output Data do not match.");
42      else if (out_data_type == DUDLEY_REDUCED_NODES)      } else if (!out->actsExpanded()) {
43      {          throw DudleyException("Assemble_CopyNodalData: expanded Data object is expected for output data.");
44      if (!numSamplesEqual(out, 1, Dudley_NodeFile_getNumReducedNodes(nodes)))      }
45      {  
46          Dudley_setError(TYPE_ERROR,      // more sophisticated test needed for overlapping node/DOF counts
47                  "Dudley_Assemble_CopyNodalData: illegal number of samples of output Data object");      if (in_data_type == DUDLEY_NODES) {
48      }          if (!in->numSamplesEqual(1, Dudley_NodeFile_getNumNodes(nodes))) {
49      }              throw DudleyException("Assemble_CopyNodalData: illegal number of samples of input Data object");
50      else if (out_data_type == DUDLEY_DEGREES_OF_FREEDOM)          }
51      {      } else if (in_data_type == DUDLEY_REDUCED_NODES) {
52      if (!numSamplesEqual(out, 1, Dudley_NodeFile_getNumDegreesOfFreedom(nodes)))          if (!in->numSamplesEqual(1, Dudley_NodeFile_getNumReducedNodes(nodes))) {
53      {              throw DudleyException("Assemble_CopyNodalData: illegal number of samples of input Data object");
54          Dudley_setError(TYPE_ERROR,          }
55                  "Dudley_Assemble_CopyNodalData: illegal number of samples of output Data object");      } else if (in_data_type == DUDLEY_DEGREES_OF_FREEDOM) {
56      }          if (!in->numSamplesEqual(1, Dudley_NodeFile_getNumDegreesOfFreedom(nodes))) {
57      }              throw DudleyException("Assemble_CopyNodalData: illegal number of samples of input Data object");
58      else if (out_data_type == DUDLEY_REDUCED_DEGREES_OF_FREEDOM)          }
59      {          if ((((out_data_type == DUDLEY_NODES) || (out_data_type == DUDLEY_DEGREES_OF_FREEDOM)) && !in->actsExpanded() && (mpiSize > 1))) {
60      if (!numSamplesEqual(out, 1, Dudley_NodeFile_getNumReducedDegreesOfFreedom(nodes)))  
61      {              throw DudleyException("Assemble_CopyNodalData: DUDLEY_DEGREES_OF_FREEDOM to DUDLEY_NODES or DUDLEY_DEGREES_OF_FREEDOM requires expanded input data on more than one processor.");
62          Dudley_setError(TYPE_ERROR,          }
63                  "Dudley_Assemble_CopyNodalData: illegal number of samples of output Data object");      } else if (in_data_type == DUDLEY_REDUCED_DEGREES_OF_FREEDOM) {
64      }          if (!in->numSamplesEqual(1, Dudley_NodeFile_getNumReducedDegreesOfFreedom(nodes))) {
65      }              throw DudleyException("Assemble_CopyNodalData: illegal number of samples of input Data object");
66      else          }
67      {          if ((out_data_type == DUDLEY_DEGREES_OF_FREEDOM) && !in->actsExpanded() && (mpiSize > 1)) {
68      Dudley_setError(TYPE_ERROR, "Dudley_Assemble_CopyNodalData: illegal function space type for source object");              throw DudleyException("Assemble_CopyNodalData: DUDLEY_REDUCED_DEGREES_OF_FREEDOM to DUDLEY_DEGREES_OF_FREEDOM requires expanded input data on more than one processor.");
69            }
70        } else {
71            throw DudleyException("Assemble_CopyNodalData: illegal function space type for target object");
72        }
73    
74        if (out_data_type == DUDLEY_NODES) {
75            if (!out->numSamplesEqual(1, Dudley_NodeFile_getNumNodes(nodes))) {
76                throw DudleyException("Assemble_CopyNodalData: illegal number of samples of output Data object");
77            }
78        } else if (out_data_type == DUDLEY_REDUCED_NODES) {
79            if (!out->numSamplesEqual(1, Dudley_NodeFile_getNumReducedNodes(nodes))) {
80                throw DudleyException("Assemble_CopyNodalData: illegal number of samples of output Data object");
81            }
82        } else if (out_data_type == DUDLEY_DEGREES_OF_FREEDOM) {
83            if (!out->numSamplesEqual(1, Dudley_NodeFile_getNumDegreesOfFreedom(nodes))) {
84                throw DudleyException("Assemble_CopyNodalData: illegal number of samples of output Data object");
85            }
86        } else if (out_data_type == DUDLEY_REDUCED_DEGREES_OF_FREEDOM) {
87            if (!out->numSamplesEqual(1, Dudley_NodeFile_getNumReducedDegreesOfFreedom(nodes))) {
88                throw DudleyException("Assemble_CopyNodalData: illegal number of samples of output Data object");
89            }
90        } else {
91            throw DudleyException("Assemble_CopyNodalData: illegal function space type for source object");
92        }
93    
94        size_t numComps_size = numComps * sizeof(double);
95    
96        /**************************** DUDLEY_NODES ******************************/
97        if (in_data_type == DUDLEY_NODES) {
98            out->requireWrite();
99            if (out_data_type == DUDLEY_NODES) {
100    #pragma omp parallel for
101                for (index_t n = 0; n < nodes->nodesMapping->numNodes; n++) {
102                    memcpy(out->getSampleDataRW(n), in->getSampleDataRO(n), numComps_size);
103                }
104            } else if (out_data_type == DUDLEY_REDUCED_NODES) {
105    #pragma omp parallel for
106                for (index_t n = 0; n < nodes->reducedNodesMapping->numTargets; n++) {
107                    memcpy(out->getSampleDataRW(n),
108                           in->getSampleDataRO(nodes->reducedNodesMapping->map[n]),
109                           numComps_size);
110                }
111            } else if (out_data_type == DUDLEY_DEGREES_OF_FREEDOM) {
112                const dim_t nComps = nodes->degreesOfFreedomDistribution->getMyNumComponents();
113    #pragma omp parallel for
114                for (index_t n = 0; n < nComps; n++) {
115                    memcpy(out->getSampleDataRW(n),
116                           in->getSampleDataRO(nodes->degreesOfFreedomMapping->map[n]), numComps_size);
117                }
118            } else if (out_data_type == DUDLEY_REDUCED_DEGREES_OF_FREEDOM) {
119                const dim_t nComps = nodes->reducedDegreesOfFreedomDistribution->getMyNumComponents();
120    #pragma omp parallel for
121                for (index_t n = 0; n < nComps; n++) {
122                    memcpy(out->getSampleDataRW(n),
123                           in->getSampleDataRO(nodes->reducedDegreesOfFreedomMapping->map[n]), numComps_size);
124                }
125            }
126        /************************ DUDLEY_REDUCED_NODES **************************/
127        } else if (in_data_type == DUDLEY_REDUCED_NODES) {
128            out->requireWrite();
129            if (out_data_type == DUDLEY_NODES) {
130                throw DudleyException("Assemble_CopyNodalData: cannot copy from reduced nodes to nodes.");
131            } else if (out_data_type == DUDLEY_REDUCED_NODES) {
132    #pragma omp parallel for
133                for (index_t n = 0; n < nodes->reducedNodesMapping->numNodes; n++) {
134                    memcpy(out->getSampleDataRW(n), in->getSampleDataRO(n), numComps_size);
135                }
136            } else if (out_data_type == DUDLEY_DEGREES_OF_FREEDOM) {
137                throw DudleyException("Assemble_CopyNodalData: cannot copy from reduced nodes to degrees of freedom.");
138            } else if (out_data_type == DUDLEY_REDUCED_DEGREES_OF_FREEDOM) {
139                const dim_t nComps = nodes->reducedDegreesOfFreedomDistribution->getMyNumComponents();
140    #pragma omp parallel for
141                for (index_t n = 0; n < nComps; n++) {
142                    const dim_t k = nodes->reducedDegreesOfFreedomMapping->map[n];
143                    memcpy(out->getSampleDataRW(n),
144                           in->getSampleDataRO(nodes->reducedNodesMapping->target[k]), numComps_size);
145                }
146            }
147        /********************** DUDLEY_DEGREES_OF_FREEDOM ***********************/
148        } else if (in_data_type == DUDLEY_DEGREES_OF_FREEDOM) {
149            out->requireWrite();
150            if (out_data_type == DUDLEY_NODES) {
151                paso::Coupler_ptr coupler(new paso::Coupler(nodes->degreesOfFreedomConnector, numComps));
152                // safe provided coupler->copyAll is called before the pointer
153                // in "in" is invalidated
154                const_cast<escript::Data*>(in)->resolve();
155                coupler->startCollect(in->getDataRO());  
156                const double* recv_buffer = coupler->finishCollect();
157                const index_t upperBound = nodes->degreesOfFreedomDistribution->getMyNumComponents();
158    #pragma omp parallel for
159                for (index_t n = 0; n < nodes->numNodes; n++) {
160                    const index_t k = nodes->degreesOfFreedomMapping->target[n];
161                    if (k < upperBound) {
162                        memcpy(out->getSampleDataRW(n), in->getSampleDataRO(k), numComps_size);
163                    } else {
164                        memcpy(out->getSampleDataRW(n),
165                               &recv_buffer[(k - upperBound) * numComps], numComps_size);
166                    }
167                }
168            } else if (out_data_type == DUDLEY_REDUCED_NODES) {
169                paso::Coupler_ptr coupler(new paso::Coupler(nodes->degreesOfFreedomConnector, numComps));
170                // safe provided coupler->copyAll is called before the pointer
171                // in "in" is invalidated
172                const_cast<escript::Data*>(in)->resolve();
173                coupler->startCollect(in->getDataRO());  
174                const double* recv_buffer = coupler->finishCollect();
175                const index_t upperBound = nodes->degreesOfFreedomDistribution->getMyNumComponents();
176    
177    #pragma omp parallel for
178                for (index_t n = 0; n < nodes->reducedNodesMapping->numTargets; n++) {
179                    const index_t l = nodes->reducedNodesMapping->map[n];
180                    const index_t k = nodes->degreesOfFreedomMapping->target[l];
181                    if (k < upperBound) {
182                        memcpy(out->getSampleDataRW(n), in->getSampleDataRO(k), numComps_size);
183                    } else {
184                        memcpy(out->getSampleDataRW(n),
185                               &recv_buffer[(k - upperBound)*numComps], numComps_size);
186                    }
187                }
188            } else if (out_data_type == DUDLEY_DEGREES_OF_FREEDOM) {
189                const dim_t nComps = nodes->degreesOfFreedomDistribution->getMyNumComponents();
190    #pragma omp parallel for
191                for (index_t n = 0; n < nComps; n++) {
192                    memcpy(out->getSampleDataRW(n), in->getSampleDataRO(n), numComps_size);
193                }
194            } else if (out_data_type == DUDLEY_REDUCED_DEGREES_OF_FREEDOM) {
195                const dim_t nComps = nodes->reducedDegreesOfFreedomDistribution->getMyNumComponents();
196    #pragma omp parallel for
197                for (index_t n = 0; n < nComps; n++) {
198                    const dim_t k = nodes->reducedDegreesOfFreedomMapping->map[n];
199                    memcpy(out->getSampleDataRW(n),
200                           in->getSampleDataRO(nodes->degreesOfFreedomMapping->target[k]), numComps_size);
201                }
202            }
203    
204        /****************** DUDLEY_REDUCED_DEGREES_OF_FREEDOM *******************/
205        } else if (in_data_type == DUDLEY_REDUCED_DEGREES_OF_FREEDOM) {
206            if (out_data_type == DUDLEY_NODES) {
207                throw DudleyException("Assemble_CopyNodalData: cannot copy from reduced degrees of freedom to nodes.");
208            } else if (out_data_type == DUDLEY_REDUCED_NODES) {
209                paso::Coupler_ptr coupler(new paso::Coupler(nodes->reducedDegreesOfFreedomConnector, numComps));
210                const dim_t upperBound = nodes->reducedDegreesOfFreedomDistribution->getMyNumComponents();
211                // safe provided coupler->copyAll is called before the pointer
212                // in "in" is invalidated
213                const_cast<escript::Data*>(in)->resolve();
214                coupler->startCollect(in->getDataRO());  
215                out->requireWrite();
216                const double* recv_buffer = coupler->finishCollect();
217    #pragma omp parallel for
218                for (index_t n = 0; n < nodes->reducedNodesMapping->numTargets; n++) {
219                    const index_t l = nodes->reducedNodesMapping->map[n];
220                    const index_t k = nodes->reducedDegreesOfFreedomMapping->target[l];
221                    if (k < upperBound) {
222                        memcpy(out->getSampleDataRW(n), in->getSampleDataRO(k), numComps_size);
223                    } else {
224                        memcpy(out->getSampleDataRW(n),
225                               &recv_buffer[(k - upperBound)*numComps], numComps_size);
226                    }
227                }
228            } else if (out_data_type == DUDLEY_REDUCED_DEGREES_OF_FREEDOM) {
229                const dim_t nComps = nodes->reducedDegreesOfFreedomDistribution->getMyNumComponents();
230                out->requireWrite();
231    #pragma omp parallel for
232                for (index_t n = 0; n < nComps; n++) {
233                    memcpy(out->getSampleDataRW(n), in->getSampleDataRO(n), numComps_size);
234                }
235            } else if (out_data_type == DUDLEY_DEGREES_OF_FREEDOM) {
236                throw DudleyException("Assemble_CopyNodalData: cannot copy from reduced degrees of freedom to degrees of freedom.");
237            }
238      }      }
239    }
240    
241      /* now we can start */  } // namespace dudley
242    
     if (Dudley_noError())  
     {  
     /*********************** DUDLEY_NODES **************************************************/  
     numComps_size = (size_t) numComps *sizeof(double);  
     if (in_data_type == DUDLEY_NODES)  
     {  
         requireWrite(out);  
         if (out_data_type == DUDLEY_NODES)  
         {  
 #pragma omp parallel private(n)  
         {  
   
 #pragma omp parallel for private(n) schedule(static)  
             for (n = 0; n < nodes->nodesMapping->numNodes; n++)  
             {  
             memcpy(getSampleDataRWFast(out, n), getSampleDataROFast(in, n), numComps_size);  
             }  
         }  
         }  
         else if (out_data_type == DUDLEY_REDUCED_NODES)  
         {  
 #pragma omp parallel private(n)  
         {  
 #pragma omp for schedule(static)  
             for (n = 0; n < nodes->reducedNodesMapping->numTargets; n++)  
             {  
             memcpy(getSampleDataRWFast(out, n),  
                    getSampleDataROFast(in, nodes->reducedNodesMapping->map[n]), numComps_size);  
             }  
         }  
         }  
         else if (out_data_type == DUDLEY_DEGREES_OF_FREEDOM)  
         {  
         int nComps = nodes->degreesOfFreedomDistribution->getMyNumComponents();  
 #pragma omp parallel private(n)  
         {  
 #pragma omp for schedule(static)  
             for (n = 0; n < nComps; n++)  
             {  
             memcpy(getSampleDataRWFast(out, n),  
                    getSampleDataROFast(in, nodes->degreesOfFreedomMapping->map[n]), numComps_size);  
             }  
         }  
         }  
         else if (out_data_type == DUDLEY_REDUCED_DEGREES_OF_FREEDOM)  
         {  
         int nComps = nodes->reducedDegreesOfFreedomDistribution->getMyNumComponents();  
 #pragma omp parallel private(n)  
         {  
 #pragma omp for schedule(static)  
             for (n = 0; n < nComps; n++)  
             {  
             memcpy(getSampleDataRWFast(out, n),  
                    getSampleDataROFast(in, nodes->reducedDegreesOfFreedomMapping->map[n]), numComps_size);  
             }  
         }  
         }  
     /*********************** DUDLEY_REDUCED_NODES **************************************************/  
     }  
     else if (in_data_type == DUDLEY_REDUCED_NODES)  
     {  
         requireWrite(out);  
         if (out_data_type == DUDLEY_NODES)  
         {  
         Dudley_setError(TYPE_ERROR, "Dudley_Assemble_CopyNodalData: cannot copy from reduced nodes to nodes.");  
   
         }  
         else if (out_data_type == DUDLEY_REDUCED_NODES)  
         {  
 #pragma omp parallel private(n)  
         {  
 #pragma omp for schedule(static)  
             for (n = 0; n < nodes->reducedNodesMapping->numNodes; n++)  
             {  
             memcpy(getSampleDataRWFast(out, n), getSampleDataROFast(in, n), numComps_size);  
             }  
         }  
         }  
         else if (out_data_type == DUDLEY_DEGREES_OF_FREEDOM)  
         {  
         Dudley_setError(TYPE_ERROR,  
                 "Dudley_Assemble_CopyNodalData: cannot copy from reduced nodes to degrees of freedom.");  
         }  
         else if (out_data_type == DUDLEY_REDUCED_DEGREES_OF_FREEDOM)  
         {  
         int nComps = nodes->reducedDegreesOfFreedomDistribution->getMyNumComponents();  
 #pragma omp parallel private(n,k)  
         {  
 #pragma omp for schedule(static)  
             for (n = 0; n < nComps; n++)  
             {  
             k = nodes->reducedDegreesOfFreedomMapping->map[n];  
             memcpy(getSampleDataRWFast(out, n),  
                    getSampleDataROFast(in, nodes->reducedNodesMapping->target[k]), numComps_size);  
             }  
         }  
         }  
   
     /*********************** DUDLEY_DEGREES_OF_FREEDOM **************************************************/  
     }  
     else if (in_data_type == DUDLEY_DEGREES_OF_FREEDOM)  
     {  
         requireWrite(out);  
         if (out_data_type == DUDLEY_NODES)  
         {  
         coupler.reset(new paso::Coupler(nodes->degreesOfFreedomConnector, numComps));  
         if (Esys_noError())  
         {  
             /* safe provided coupler->copyAll is called before the pointer in "in" is invalidated */  
             const_cast<escript::Data*>(in)->resolve();  
             coupler->startCollect(in->getDataRO());    
             recv_buffer = coupler->finishCollect();  
             upperBound = nodes->degreesOfFreedomDistribution->getMyNumComponents();  
 #pragma omp parallel private(n,k)  
             {  
 #pragma omp for schedule(static)  
             for (n = 0; n < nodes->numNodes; n++)  
             {  
                 k = nodes->degreesOfFreedomMapping->target[n];  
                 if (k < upperBound)  
                 {  
                 memcpy(getSampleDataRWFast(out, n), getSampleDataROFast(in, k), numComps_size);  
                 }  
                 else  
                 {  
                 memcpy(getSampleDataRWFast(out, n),  
                        &recv_buffer[(k - upperBound) * numComps], numComps_size);  
                 }  
             }  
             }  
         }  
         }  
         else if (out_data_type == DUDLEY_REDUCED_NODES)  
         {  
         coupler.reset(new paso::Coupler(nodes->degreesOfFreedomConnector, numComps));  
         if (Esys_noError())  
         {  
             /* safe provided coupler->copyAll is called before the pointer in "in" is invalidated */  
             const_cast<escript::Data*>(in)->resolve();  
             coupler->startCollect(in->getDataRO());    
             recv_buffer = coupler->finishCollect();  
             upperBound = nodes->degreesOfFreedomDistribution->getMyNumComponents();  
             requireWrite(out);  
   
 #pragma omp parallel private(n,k,l)  
             {  
 #pragma omp for schedule(static)  
             for (n = 0; n < nodes->reducedNodesMapping->numTargets; n++)  
             {  
                 l = nodes->reducedNodesMapping->map[n];  
                 k = nodes->degreesOfFreedomMapping->target[l];  
                 if (k < upperBound)  
                 {  
                 memcpy(getSampleDataRWFast(out, n), getSampleDataROFast(in, k), numComps_size);  
                 }  
                 else  
                 {  
                 memcpy(getSampleDataRWFast(out, n),  
                        &recv_buffer[(k - upperBound) * numComps], numComps_size);  
                 }  
             }  
             }  
         }  
         }  
         else if (out_data_type == DUDLEY_DEGREES_OF_FREEDOM)  
         {  
         int nComps = nodes->degreesOfFreedomDistribution->getMyNumComponents();  
         requireWrite(out);  
 #pragma omp parallel private(n)  
         {  
 #pragma omp for schedule(static)  
             for (n = 0; n < nComps; n++)  
             {  
             memcpy(getSampleDataRWFast(out, n), getSampleDataROFast(in, n), numComps_size);  
             }  
         }  
         }  
         else if (out_data_type == DUDLEY_REDUCED_DEGREES_OF_FREEDOM)  
         {  
         int nComps = nodes->reducedDegreesOfFreedomDistribution->getMyNumComponents();  
         requireWrite(out);  
 #pragma omp parallel private(n,k)  
         {  
 #pragma omp for schedule(static)  
             for (n = 0; n < nComps; n++)  
             {  
             k = nodes->reducedDegreesOfFreedomMapping->map[n];  
             memcpy(getSampleDataRWFast(out, n),  
                    getSampleDataROFast(in, nodes->degreesOfFreedomMapping->target[k]), numComps_size);  
             }  
         }  
         }  
   
     /*********************** DUDLEY_REDUCED_DEGREES_OF_FREEDOM **************************************************/  
     }  
     else if (in_data_type == DUDLEY_REDUCED_DEGREES_OF_FREEDOM)  
     {  
   
         if (out_data_type == DUDLEY_NODES)  
         {  
         Dudley_setError(TYPE_ERROR,  
                 "Dudley_Assemble_CopyNodalData: cannot copy from reduced degrees of freedom to nodes.");  
         }  
         else if (out_data_type == DUDLEY_REDUCED_NODES)  
         {  
         coupler.reset(new paso::Coupler(nodes->reducedDegreesOfFreedomConnector, numComps));  
         if (Esys_noError())  
         {  
             upperBound = nodes->reducedDegreesOfFreedomDistribution->getMyNumComponents();  
             /* safe provided coupler->copyAll is called before the pointer in "in" is invalidated */  
             const_cast<escript::Data*>(in)->resolve();  
             coupler->startCollect(in->getDataRO());    
             recv_buffer = coupler->finishCollect();  
             requireWrite(out);  
 #pragma omp parallel private(n,k,l)  
             {  
 #pragma omp for schedule(static)  
             for (n = 0; n < nodes->reducedNodesMapping->numTargets; n++)  
             {  
                 l = nodes->reducedNodesMapping->map[n];  
                 k = nodes->reducedDegreesOfFreedomMapping->target[l];  
                 if (k < upperBound)  
                 {  
                 memcpy(getSampleDataRWFast(out, n), getSampleDataROFast(in, k), numComps_size);  
                 }  
                 else  
                 {  
                 memcpy(getSampleDataRWFast(out, n),  
                        &recv_buffer[(k - upperBound) * numComps], numComps_size);  
                 }  
             }  
             }  
         }  
         }  
         else if (out_data_type == DUDLEY_REDUCED_DEGREES_OF_FREEDOM)  
         {  
         int nComps = nodes->reducedDegreesOfFreedomDistribution->getMyNumComponents();  
         requireWrite(out);  
 #pragma omp parallel private(n)  
         {  
 #pragma omp for schedule(static)  
             for (n = 0; n < nComps; n++)  
             {  
             memcpy(getSampleDataRWFast(out, n), getSampleDataROFast(in, n), numComps_size);  
             }  
         }  
         }  
         else if (out_data_type == DUDLEY_DEGREES_OF_FREEDOM)  
         {  
         Dudley_setError(TYPE_ERROR,  
                 "Dudley_Assemble_CopyNodalData: cannot copy from reduced degrees of freedom to degrees of freedom.");  
         }  
     }  
     }  
     return;  
 }  

Legend:
Removed from v.6008  
changed lines
  Added in v.6009

  ViewVC Help
Powered by ViewVC 1.1.26