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

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

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

revision 4491 by caltinay, Fri Jun 7 02:23:49 2013 UTC revision 4492 by caltinay, Tue Jul 2 01:44:11 2013 UTC
# Line 26  Line 26 
26    
27  namespace finley {  namespace finley {
28    
29  void Assemble_CopyNodalData(NodeFile* nodes, escript::Data& out,  void Assemble_CopyNodalData(const NodeFile* nodes, escript::Data& out,
30                              const escript::Data& in)                              const escript::Data& in)
31  {  {
32      Finley_resetError();      Finley_resetError();
# Line 72  void Assemble_CopyNodalData(NodeFile* no Line 72  void Assemble_CopyNodalData(NodeFile* no
72          Finley_setError(TYPE_ERROR, "Assemble_CopyNodalData: illegal function space type for target object");          Finley_setError(TYPE_ERROR, "Assemble_CopyNodalData: illegal function space type for target object");
73      }      }
74    
75      if (out_data_type == FINLEY_NODES) {      int numOut=0;
76          if (!out.numSamplesEqual(1, nodes->getNumNodes())) {      switch (out_data_type) {
77              Finley_setError(TYPE_ERROR,"Assemble_CopyNodalData: illegal number of samples of output Data object");          case FINLEY_NODES:
78          }              numOut=nodes->getNumNodes();
79      } else if (out_data_type == FINLEY_REDUCED_NODES) {              break;
80          if (!out.numSamplesEqual(1, nodes->getNumReducedNodes())) {  
81              Finley_setError(TYPE_ERROR,"Assemble_CopyNodalData: illegal number of samples of output Data object");          case FINLEY_REDUCED_NODES:
82          }              numOut=nodes->getNumReducedNodes();
83      } else if (out_data_type == FINLEY_DEGREES_OF_FREEDOM) {              break;
84          if (!out.numSamplesEqual(1, nodes->getNumDegreesOfFreedom())) {  
85              Finley_setError(TYPE_ERROR,"Assemble_CopyNodalData: illegal number of samples of output Data object");          case FINLEY_DEGREES_OF_FREEDOM:
86          }              numOut=nodes->getNumDegreesOfFreedom();
87      } else if (out_data_type == FINLEY_REDUCED_DEGREES_OF_FREEDOM) {              break;
88          if (!out.numSamplesEqual(1, nodes->getNumReducedDegreesOfFreedom())) {  
89              Finley_setError(TYPE_ERROR,"Assemble_CopyNodalData: illegal number of samples of output Data object");          case FINLEY_REDUCED_DEGREES_OF_FREEDOM:
90          }              numOut=nodes->getNumReducedDegreesOfFreedom();
91      } else {              break;
92          Finley_setError(TYPE_ERROR,"Assemble_CopyNodalData: illegal function space type for source object");  
93            default:
94                Finley_setError(TYPE_ERROR,"Assemble_CopyNodalData: illegal function space type for source object");
95        }
96    
97        if (!out.numSamplesEqual(1, numOut)) {
98            Finley_setError(TYPE_ERROR,"Assemble_CopyNodalData: illegal number of samples of output Data object");
99      }      }
100    
101      if (!Finley_noError())      if (!Finley_noError())
# Line 103  void Assemble_CopyNodalData(NodeFile* no Line 109  void Assemble_CopyNodalData(NodeFile* no
109          out.requireWrite();          out.requireWrite();
110          if (out_data_type == FINLEY_NODES) {          if (out_data_type == FINLEY_NODES) {
111  #pragma omp parallel for  #pragma omp parallel for
112              for (int n=0; n<nodes->nodesMapping->numNodes; n++) {              for (int n=0; n<numOut; n++) {
113                  memcpy(out.getSampleDataRW(n), _in.getSampleDataRO(n), numComps_size);                  memcpy(out.getSampleDataRW(n), _in.getSampleDataRO(n), numComps_size);
114              }              }
115          } else if (out_data_type == FINLEY_REDUCED_NODES) {          } else if (out_data_type == FINLEY_REDUCED_NODES) {
116                const std::vector<int>& map = nodes->borrowReducedNodesTarget();
117  #pragma omp parallel for  #pragma omp parallel for
118              for (int n=0; n<nodes->reducedNodesMapping->numTargets; n++) {              for (int n=0; n<map.size(); n++) {
119                  memcpy(out.getSampleDataRW(n),                  memcpy(out.getSampleDataRW(n), _in.getSampleDataRO(map[n]),
                        _in.getSampleDataRO(nodes->reducedNodesMapping->map[n]),  
120                         numComps_size);                         numComps_size);
121              }              }
122          } else if (out_data_type == FINLEY_DEGREES_OF_FREEDOM) {          } else if (out_data_type == FINLEY_DEGREES_OF_FREEDOM) {
123              int nComps = Paso_Distribution_getMyNumComponents(nodes->degreesOfFreedomDistribution);              const std::vector<int>& map = nodes->borrowDegreesOfFreedomTarget();
124  #pragma omp parallel for  #pragma omp parallel for
125              for (int n=0; n<nComps; n++) {              for (int n=0; n<numOut; n++) {
126                  memcpy(out.getSampleDataRW(n),                  memcpy(out.getSampleDataRW(n), _in.getSampleDataRO(map[n]),
                        _in.getSampleDataRO(nodes->degreesOfFreedomMapping->map[n]),  
127                         numComps_size);                         numComps_size);
128              }              }
129          } else if (out_data_type == FINLEY_REDUCED_DEGREES_OF_FREEDOM) {          } else if (out_data_type == FINLEY_REDUCED_DEGREES_OF_FREEDOM) {
130              int nComps = Paso_Distribution_getMyNumComponents(nodes->reducedDegreesOfFreedomDistribution);              const std::vector<int>& map = nodes->borrowReducedDegreesOfFreedomTarget();
131  #pragma omp parallel for  #pragma omp parallel for
132              for (int n=0; n<nComps; n++) {              for (int n=0; n<numOut; n++) {
133                  memcpy(out.getSampleDataRW(n),                  memcpy(out.getSampleDataRW(n), _in.getSampleDataRO(map[n]),
                        _in.getSampleDataRO(nodes->reducedDegreesOfFreedomMapping->map[n]),  
134                         numComps_size);                         numComps_size);
135              }              }
136          }          }
137    
138      /*********************** FINLEY_REDUCED_NODES ***************************/      /*********************** FINLEY_REDUCED_NODES ***************************/
139      } else if (in_data_type == FINLEY_REDUCED_NODES) {      } else if (in_data_type == FINLEY_REDUCED_NODES) {
         out.requireWrite();  
140          if (out_data_type == FINLEY_NODES) {          if (out_data_type == FINLEY_NODES) {
141              Finley_setError(TYPE_ERROR,"Assemble_CopyNodalData: cannot copy from reduced nodes to nodes.");              Finley_setError(TYPE_ERROR,"Assemble_CopyNodalData: cannot copy from reduced nodes to nodes.");
142          } else if (out_data_type == FINLEY_REDUCED_NODES) {          } else if (out_data_type == FINLEY_REDUCED_NODES) {
143                out.requireWrite();
144  #pragma omp parallel for  #pragma omp parallel for
145              for (int n=0; n<nodes->reducedNodesMapping->numNodes; n++) {              for (int n=0; n<nodes->getNumNodes(); n++) {
146                  memcpy(out.getSampleDataRW(n), _in.getSampleDataRO(n), numComps_size);                  memcpy(out.getSampleDataRW(n), _in.getSampleDataRO(n), numComps_size);
147              }              }
148         } else if (out_data_type == FINLEY_DEGREES_OF_FREEDOM) {         } else if (out_data_type == FINLEY_DEGREES_OF_FREEDOM) {
149              Finley_setError(TYPE_ERROR,"Assemble_CopyNodalData: cannot copy from reduced nodes to degrees of freedom.");              Finley_setError(TYPE_ERROR,"Assemble_CopyNodalData: cannot copy from reduced nodes to degrees of freedom.");
150         } else if (out_data_type == FINLEY_REDUCED_DEGREES_OF_FREEDOM) {         } else if (out_data_type == FINLEY_REDUCED_DEGREES_OF_FREEDOM) {
151              int nComps = Paso_Distribution_getMyNumComponents(nodes->reducedDegreesOfFreedomDistribution);              out.requireWrite();
152                const int* target = nodes->borrowTargetReducedNodes();
153                const std::vector<int>& map = nodes->borrowReducedDegreesOfFreedomTarget();
154  #pragma omp parallel for  #pragma omp parallel for
155              for (int n=0; n<nComps; n++) {              for (int n=0; n<numOut; n++) {
                const int k = nodes->reducedDegreesOfFreedomMapping->map[n];  
156                 memcpy(out.getSampleDataRW(n),                 memcpy(out.getSampleDataRW(n),
157                        _in.getSampleDataRO(nodes->reducedNodesMapping->target[k]),                        _in.getSampleDataRO(target[map[n]]), numComps_size);
                       numComps_size);  
158              }              }
159          }          }
160    
# Line 167  void Assemble_CopyNodalData(NodeFile* no Line 171  void Assemble_CopyNodalData(NodeFile* no
171                  _in.requireWrite();                  _in.requireWrite();
172                  Paso_Coupler_startCollect(coupler, _in.getSampleDataRW(0));                  Paso_Coupler_startCollect(coupler, _in.getSampleDataRW(0));
173                  const double *recv_buffer=Paso_Coupler_finishCollect(coupler);                  const double *recv_buffer=Paso_Coupler_finishCollect(coupler);
174                  const int upperBound=Paso_Distribution_getMyNumComponents(nodes->degreesOfFreedomDistribution);                  const int upperBound=nodes->getNumDegreesOfFreedom();
175                    const int* target = nodes->borrowTargetDegreesOfFreedom();
176  #pragma omp parallel for  #pragma omp parallel for
177                  for (int n=0; n<nodes->numNodes; n++) {                  for (int n=0; n<nodes->numNodes; n++) {
178                      const int k=nodes->degreesOfFreedomMapping->target[n];                      const int k=target[n];
179                      if (k < upperBound) {                      if (k < upperBound) {
180                          memcpy(out.getSampleDataRW(n), _in.getSampleDataRO(k),                          memcpy(out.getSampleDataRW(n), _in.getSampleDataRO(k),
181                                 numComps_size);                                 numComps_size);
# Line 188  void Assemble_CopyNodalData(NodeFile* no Line 193  void Assemble_CopyNodalData(NodeFile* no
193                  _in.requireWrite(); // See comment above about coupler and const                  _in.requireWrite(); // See comment above about coupler and const
194                  Paso_Coupler_startCollect(coupler, _in.getSampleDataRW(0));                  Paso_Coupler_startCollect(coupler, _in.getSampleDataRW(0));
195                  const double *recv_buffer=Paso_Coupler_finishCollect(coupler);                  const double *recv_buffer=Paso_Coupler_finishCollect(coupler);
196                  const int upperBound=Paso_Distribution_getMyNumComponents(nodes->degreesOfFreedomDistribution);                  const int upperBound=nodes->getNumDegreesOfFreedom();
197                    const std::vector<int>& map = nodes->borrowReducedNodesTarget();
198                    const int* target = nodes->borrowTargetDegreesOfFreedom();
199    
200  #pragma omp parallel for  #pragma omp parallel for
201                  for (int n=0; n<nodes->reducedNodesMapping->numTargets; n++) {                  for (int n=0; n<map.size(); n++) {
202                      const int l=nodes->reducedNodesMapping->map[n];                      const int k=target[map[n]];
                     const int k=nodes->degreesOfFreedomMapping->target[l];  
203                      if (k < upperBound) {                      if (k < upperBound) {
204                          memcpy(out.getSampleDataRW(n), _in.getSampleDataRO(k),                          memcpy(out.getSampleDataRW(n), _in.getSampleDataRO(k),
205                                 numComps_size);                                 numComps_size);
# Line 206  void Assemble_CopyNodalData(NodeFile* no Line 212  void Assemble_CopyNodalData(NodeFile* no
212              }              }
213              Paso_Coupler_free(coupler);              Paso_Coupler_free(coupler);
214          } else if (out_data_type == FINLEY_DEGREES_OF_FREEDOM) {          } else if (out_data_type == FINLEY_DEGREES_OF_FREEDOM) {
             const int nComps = Paso_Distribution_getMyNumComponents(nodes->degreesOfFreedomDistribution);  
215  #pragma omp parallel for  #pragma omp parallel for
216              for (int n=0; n<nComps; n++) {              for (int n=0; n<numOut; n++) {
217                  memcpy(out.getSampleDataRW(n), _in.getSampleDataRO(n),                  memcpy(out.getSampleDataRW(n), _in.getSampleDataRO(n),
218                         numComps_size);                         numComps_size);
219              }              }
220          } else if (out_data_type == FINLEY_REDUCED_DEGREES_OF_FREEDOM) {          } else if (out_data_type == FINLEY_REDUCED_DEGREES_OF_FREEDOM) {
221              const int nComps = Paso_Distribution_getMyNumComponents(nodes->reducedDegreesOfFreedomDistribution);              const std::vector<int>& map = nodes->borrowReducedDegreesOfFreedomTarget();
222                const int* target = nodes->borrowTargetDegreesOfFreedom();
223  #pragma omp parallel for  #pragma omp parallel for
224              for (int n=0; n<nComps; n++) {              for (int n=0; n<numOut; n++) {
                 const int k=nodes->reducedDegreesOfFreedomMapping->map[n];  
225                  memcpy(out.getSampleDataRW(n),                  memcpy(out.getSampleDataRW(n),
226                         _in.getSampleDataRO(nodes->degreesOfFreedomMapping->target[k]),                         _in.getSampleDataRO(target[map[n]]), numComps_size);
                        numComps_size);  
227              }              }
228          }          }
229    
# Line 230  void Assemble_CopyNodalData(NodeFile* no Line 234  void Assemble_CopyNodalData(NodeFile* no
234          } else if (out_data_type == FINLEY_REDUCED_NODES) {          } else if (out_data_type == FINLEY_REDUCED_NODES) {
235              Paso_Coupler *coupler=Paso_Coupler_alloc(nodes->reducedDegreesOfFreedomConnector,numComps);              Paso_Coupler *coupler=Paso_Coupler_alloc(nodes->reducedDegreesOfFreedomConnector,numComps);
236              if (Esys_noError()) {              if (Esys_noError()) {
                 const int upperBound=Paso_Distribution_getMyNumComponents(nodes->reducedDegreesOfFreedomDistribution);  
237                  _in.requireWrite(); // See comment about coupler and const                  _in.requireWrite(); // See comment about coupler and const
238                  Paso_Coupler_startCollect(coupler, _in.getSampleDataRW(0));                  Paso_Coupler_startCollect(coupler, _in.getSampleDataRW(0));
                 const double *recv_buffer=Paso_Coupler_finishCollect(coupler);  
239                  out.requireWrite();                  out.requireWrite();
240                    const int upperBound=nodes->getNumReducedDegreesOfFreedom();
241                    const std::vector<int>& map=nodes->borrowReducedNodesTarget();
242                    const int* target=nodes->borrowTargetReducedDegreesOfFreedom();
243                    const double *recv_buffer=Paso_Coupler_finishCollect(coupler);
244  #pragma omp parallel for  #pragma omp parallel for
245                  for (int n=0; n<nodes->reducedNodesMapping->numTargets; n++) {                  for (int n=0; n<map.size(); n++) {
246                      const int l=nodes->reducedNodesMapping->map[n];                      const int k=target[map[n]];
                     const int k=nodes->reducedDegreesOfFreedomMapping->target[l];  
247                      if (k < upperBound) {                      if (k < upperBound) {
248                          memcpy(out.getSampleDataRW(n), _in.getSampleDataRO(k),                          memcpy(out.getSampleDataRW(n), _in.getSampleDataRO(k),
249                                 numComps_size);                                 numComps_size);
# Line 251  void Assemble_CopyNodalData(NodeFile* no Line 256  void Assemble_CopyNodalData(NodeFile* no
256              }              }
257              Paso_Coupler_free(coupler);              Paso_Coupler_free(coupler);
258          } else if (out_data_type == FINLEY_REDUCED_DEGREES_OF_FREEDOM) {          } else if (out_data_type == FINLEY_REDUCED_DEGREES_OF_FREEDOM) {
             const int nComps = Paso_Distribution_getMyNumComponents(nodes->reducedDegreesOfFreedomDistribution);  
259              out.requireWrite();              out.requireWrite();
260  #pragma omp parallel for  #pragma omp parallel for
261              for (int n=0; n<nComps; n++) {              for (int n=0; n<numOut; n++) {
262                  memcpy(out.getSampleDataRW(n), _in.getSampleDataRO(n), numComps_size);                  memcpy(out.getSampleDataRW(n), _in.getSampleDataRO(n), numComps_size);
263              }              }
264          } else if (out_data_type == FINLEY_DEGREES_OF_FREEDOM ) {          } else if (out_data_type == FINLEY_DEGREES_OF_FREEDOM ) {

Legend:
Removed from v.4491  
changed lines
  Added in v.4492

  ViewVC Help
Powered by ViewVC 1.1.26