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

Contents of /trunk-mpi-branch/finley/src/Assemble_CopyNodalData.c

Parent Directory Parent Directory | Revision Log Revision Log


Revision 1296 - (show annotations)
Tue Sep 11 05:10:22 2007 UTC (12 years, 8 months ago) by ksteube
File MIME type: text/plain
File size: 14388 byte(s)
Now compiles on ess after merge

1 /*
2 ************************************************************
3 * Copyright 2006 by ACcESS MNRF *
4 * *
5 * http://www.access.edu.au *
6 * Primary Business: Queensland, Australia *
7 * Licensed under the Open Software License version 3.0 *
8 * http://www.opensource.org/licenses/osl-3.0.php *
9 * *
10 ************************************************************
11 */
12 /**************************************************************/
13
14 /* assemblage routines: copies data between different types nodal representation */
15
16 /**************************************************************/
17
18 /* author: gross@access.edu.au */
19 /* Version: $Id$ */
20
21 /**************************************************************/
22
23 #include "Util.h"
24 #include "Assemble.h"
25 #ifdef _OPENMP
26 #include <omp.h>
27 #endif
28
29 void Finley_Assemble_CopyNodalData(Finley_NodeFile* nodes,escriptDataC* out,escriptDataC* in) {
30 dim_t n,i,k,l, mpiSize;
31 dim_t numComps=getDataPointSize(out);
32 type_t in_data_type=getFunctionSpaceType(in);
33 type_t out_data_type=getFunctionSpaceType(out);
34 index_t upperBound;
35 double* recv_buffer;
36 size_t numComps_size=0;
37 Finley_resetError();
38 if (nodes==NULL) return;
39 mpiSize=nodes->MPIInfo->size;
40
41 /* check out and in */
42 if (numComps!=getDataPointSize(in)) {
43 Finley_setError(TYPE_ERROR,"Finley_Assemble_CopyNodalData: number of components of input and output Data do not match.");
44 } else if (!isExpanded(out)) {
45 Finley_setError(TYPE_ERROR,"Finley_Assemble_CopyNodalData: expanded Data object is expected for output data.");
46 }
47
48 /* more sophisticated test needed for overlapping node/DOF counts */
49 if (in_data_type == FINLEY_NODES) {
50 if (! numSamplesEqual(in,1,Finley_NodeFile_getNumNodes(nodes))) {
51 Finley_setError(TYPE_ERROR,"Finley_Assemble_CopyNodalData: illegal number of samples of input Data object");
52 }
53 } else if (in_data_type == FINLEY_REDUCED_NODES) {
54 if (! numSamplesEqual(in,1,Finley_NodeFile_getNumReducedNodes(nodes))) {
55 Finley_setError(TYPE_ERROR,"Finley_Assemble_CopyNodalData: illegal number of samples of input Data object");
56 }
57 } else if (in_data_type == FINLEY_DEGREES_OF_FREEDOM) {
58 if (! numSamplesEqual(in,1,Finley_NodeFile_getNumDegreesOfFreedom(nodes))) {
59 Finley_setError(TYPE_ERROR,"Finley_Assemble_CopyNodalData: illegal number of samples of input Data object");
60 }
61 if ( (((out_data_type == FINLEY_NODES) || (out_data_type == FINLEY_DEGREES_OF_FREEDOM)) && !isExpanded(in) && (mpiSize>1))) {
62
63 Finley_setError(TYPE_ERROR,"Finley_Assemble_CopyNodalData: FINLEY_DEGREES_OF_FREEDOM to FINLEY_NODES or FINLEY_DEGREES_OF_FREEDOM requires expanded input data on more than one processor.");
64 }
65 } else if (in_data_type == FINLEY_REDUCED_DEGREES_OF_FREEDOM) {
66 if (! numSamplesEqual(in,1,Finley_NodeFile_getNumReducedDegreesOfFreedom(nodes))) {
67 Finley_setError(TYPE_ERROR,"Finley_Assemble_CopyNodalData: illegal number of samples of input Data object");
68 }
69 if ( (out_data_type == FINLEY_DEGREES_OF_FREEDOM) && !isExpanded(in) && (mpiSize>1)) {
70
71 Finley_setError(TYPE_ERROR,"Finley_Assemble_CopyNodalData: FINLEY_REDUCED_DEGREES_OF_FREEDOM to FINLEY_DEGREES_OF_FREEDOM requires expanded input data on more than one processor.");
72 }
73 } else {
74 Finley_setError(TYPE_ERROR,"Finley_Assemble_CopyNodalData: illegal function space type for target object");
75 }
76
77 if (out_data_type == FINLEY_NODES) {
78 if (! numSamplesEqual(out,1,Finley_NodeFile_getNumNodes(nodes))) {
79 Finley_setError(TYPE_ERROR,"Finley_Assemble_CopyNodalData: illegal number of samples of output Data object");
80 }
81 } else if (out_data_type == FINLEY_REDUCED_NODES) {
82 if (! numSamplesEqual(out,1,Finley_NodeFile_getNumReducedNodes(nodes))) {
83 Finley_setError(TYPE_ERROR,"Finley_Assemble_CopyNodalData: illegal number of samples of output Data object");
84 }
85 } else if (out_data_type == FINLEY_DEGREES_OF_FREEDOM) {
86 if (! numSamplesEqual(out,1,Finley_NodeFile_getNumDegreesOfFreedom(nodes))) {
87 Finley_setError(TYPE_ERROR,"Finley_Assemble_CopyNodalData: illegal number of samples of output Data object");
88 }
89 } else if (out_data_type == FINLEY_REDUCED_DEGREES_OF_FREEDOM) {
90 if (! numSamplesEqual(out,1,Finley_NodeFile_getNumReducedDegreesOfFreedom(nodes))) {
91 Finley_setError(TYPE_ERROR,"Finley_Assemble_CopyNodalData: illegal number of samples of output Data object");
92 }
93 } else {
94 Finley_setError(TYPE_ERROR,"Finley_Assemble_CopyNodalData: illegal function space type for source object");
95 }
96
97 /* now we can start */
98
99 if (Finley_noError()) {
100 /*********************** FINLEY_NODES **************************************************/
101 numComps_size=(size_t)numComps*sizeof(double);
102 if (in_data_type == FINLEY_NODES) {
103
104 if (out_data_type == FINLEY_NODES) {
105 #pragma omp parallel for private(n) schedule(static)
106 for (n=0;n<nodes->nodesMapping->numNodes;n++) {
107 memcpy(getSampleDataFast(out,n), getSampleDataFast(in,n), numComps_size);
108 }
109
110 } else if (out_data_type == FINLEY_REDUCED_NODES) {
111 #pragma omp parallel for private(n,i) schedule(static)
112 for (n=0;n<nodes->reducedNodesMapping->numTargets;n++) {
113 memcpy(getSampleDataFast(out,n),
114 getSampleDataFast(in,nodes->reducedNodesMapping->map[n]),
115 numComps_size);
116 }
117 } else if (out_data_type == FINLEY_DEGREES_OF_FREEDOM) {
118 int nComps = Paso_Distribution_getMyNumComponents(nodes->degreesOfFreedomDistribution);
119 #pragma omp parallel for private(n) schedule(static)
120 for (n=0;n<nComps;n++) {
121 memcpy(getSampleDataFast(out,n),
122 getSampleDataFast(in,nodes->degreesOfFreedomMapping->map[n]),
123 numComps_size);
124 }
125
126 } else if (out_data_type == FINLEY_REDUCED_DEGREES_OF_FREEDOM) {
127 int nComps = Paso_Distribution_getMyNumComponents(nodes->reducedDegreesOfFreedomDistribution);
128 #pragma omp parallel for private(n,i) schedule(static)
129 for (n=0;n<nComps;n++) {
130 memcpy(getSampleDataFast(out,n),
131 getSampleDataFast(in,nodes->reducedDegreesOfFreedomMapping->map[n]),
132 numComps_size);
133 }
134 }
135 /*********************** FINLEY_REDUCED_NODES **************************************************/
136 } else if (in_data_type == FINLEY_REDUCED_NODES) {
137
138 if (out_data_type == FINLEY_NODES) {
139 Finley_setError(TYPE_ERROR,"Finley_Assemble_CopyNodalData: cannot copy from reduced nodes to nodes.");
140
141 } else if (out_data_type == FINLEY_REDUCED_NODES) {
142 #pragma omp parallel for private(n) schedule(static)
143 for (n=0;n<nodes->reducedNodesMapping->numNodes;n++) {
144 memcpy(getSampleDataFast(out,n),getSampleDataFast(in,n),numComps_size);
145 }
146
147 } else if (out_data_type == FINLEY_DEGREES_OF_FREEDOM) {
148 Finley_setError(TYPE_ERROR,"Finley_Assemble_CopyNodalData: cannot copy from reduced nodes to degrees of freedom.");
149 } else if (out_data_type == FINLEY_REDUCED_DEGREES_OF_FREEDOM) {
150 int nComps = Paso_Distribution_getMyNumComponents(nodes->reducedDegreesOfFreedomDistribution);
151 #pragma omp parallel for private(n,k) schedule(static)
152 for (n=0;n<nComps;n++) {
153 k=nodes->reducedDegreesOfFreedomMapping->map[n];
154 memcpy(getSampleDataFast(out,n),
155 getSampleDataFast(in,nodes->reducedNodesMapping->target[k]),
156 numComps_size);
157 }
158 }
159
160 /*********************** FINLEY_DEGREES_OF_FREEDOM **************************************************/
161 } else if (in_data_type == FINLEY_DEGREES_OF_FREEDOM) {
162
163 if (out_data_type == FINLEY_NODES) {
164 Paso_Coupler_allocBuffer(nodes->degreesOfFreedomCoupler,numComps);
165 if (Paso_noError()) {
166 Paso_Coupler_startCollect(nodes->degreesOfFreedomCoupler,getSampleDataFast(in,0));
167 recv_buffer=Paso_Coupler_finishCollect(nodes->degreesOfFreedomCoupler);
168 upperBound=Paso_Distribution_getMyNumComponents(nodes->degreesOfFreedomDistribution);
169 #pragma omp parallel for private(n,k) schedule(static)
170 for (n=0;n<nodes->numNodes;n++) {
171 k=nodes->degreesOfFreedomMapping->target[n];
172 if (k < upperBound) {
173 memcpy(getSampleDataFast(out,n),
174 getSampleDataFast(in,k),
175 numComps_size);
176 } else {
177 memcpy(getSampleDataFast(out,n),
178 &recv_buffer[(k-upperBound)*numComps],
179 numComps_size);
180 }
181 }
182 Paso_Coupler_freeBuffer(nodes->degreesOfFreedomCoupler);
183 }
184
185 } else if (out_data_type == FINLEY_REDUCED_NODES) {
186 Paso_Coupler_allocBuffer(nodes->degreesOfFreedomCoupler,numComps);
187 if (Paso_noError()) {
188 Paso_Coupler_startCollect(nodes->degreesOfFreedomCoupler,getSampleDataFast(in,0));
189 recv_buffer=Paso_Coupler_finishCollect(nodes->degreesOfFreedomCoupler);
190 upperBound=Paso_Distribution_getMyNumComponents(nodes->degreesOfFreedomDistribution);
191 #pragma omp parallel for private(n,k,l) schedule(static)
192 for (n=0;n<nodes->reducedNodesMapping->numTargets;n++) {
193 l=nodes->reducedNodesMapping->map[n];
194 k=nodes->degreesOfFreedomMapping->target[l];
195 if (k < upperBound) {
196 memcpy(getSampleDataFast(out,n),
197 getSampleDataFast(in,k),
198 numComps_size);
199 } else {
200 memcpy(getSampleDataFast(out,n),
201 &recv_buffer[(k-upperBound)*numComps],
202 numComps_size);
203 }
204 }
205 Paso_Coupler_freeBuffer(nodes->degreesOfFreedomCoupler);
206 }
207 } else if (out_data_type == FINLEY_DEGREES_OF_FREEDOM) {
208 int nComps = Paso_Distribution_getMyNumComponents(nodes->degreesOfFreedomDistribution);
209 #pragma omp parallel for private(n) schedule(static)
210 for (n=0;n<nComps;n++) {
211 memcpy(getSampleDataFast(out,n),getSampleDataFast(in,n),numComps_size);
212 }
213
214 } else if (out_data_type == FINLEY_REDUCED_DEGREES_OF_FREEDOM) {
215 int nComps = Paso_Distribution_getMyNumComponents(nodes->reducedDegreesOfFreedomDistribution);
216 #pragma omp parallel for private(n,k) schedule(static)
217 for (n=0;n<nComps;n++) {
218 k=nodes->reducedDegreesOfFreedomMapping->map[n];
219 memcpy(getSampleDataFast(out,n),
220 getSampleDataFast(in,nodes->degreesOfFreedomMapping->target[k]),
221 numComps_size);
222 }
223 }
224
225 } else if (in_data_type == FINLEY_REDUCED_DEGREES_OF_FREEDOM) {
226
227 if (out_data_type == FINLEY_NODES) {
228 Finley_setError(TYPE_ERROR,"Finley_Assemble_CopyNodalData: cannot copy from reduced degrees of freedom to nodes.");
229
230 } else if (out_data_type == FINLEY_REDUCED_NODES) {
231 Paso_Coupler_allocBuffer(nodes->reducedDegreesOfFreedomCoupler,numComps);
232 if (Paso_noError()) {
233 Paso_Coupler_startCollect(nodes->reducedDegreesOfFreedomCoupler,getSampleDataFast(in,0));
234 recv_buffer=Paso_Coupler_finishCollect(nodes->reducedDegreesOfFreedomCoupler);
235 upperBound=Paso_Distribution_getMyNumComponents(nodes->reducedDegreesOfFreedomDistribution);
236 #pragma omp parallel for private(n,k,l) schedule(static)
237 for (n=0;n<nodes->reducedNodesMapping->numTargets;n++) {
238 l=nodes->reducedNodesMapping->map[n];
239 k=nodes->reducedDegreesOfFreedomMapping->target[l];
240 if (k < upperBound) {
241 memcpy(getSampleDataFast(out,n),
242 getSampleDataFast(in,k),
243 numComps_size);
244 } else {
245 memcpy(getSampleDataFast(out,n),
246 &recv_buffer[(k-upperBound)*numComps],
247 numComps_size);
248 }
249 }
250 Paso_Coupler_freeBuffer(nodes->reducedDegreesOfFreedomCoupler);
251 }
252
253 } else if (out_data_type == FINLEY_REDUCED_DEGREES_OF_FREEDOM) {
254 int nComps = Paso_Distribution_getMyNumComponents(nodes->reducedDegreesOfFreedomDistribution);
255 #pragma omp parallel for private(n) schedule(static)
256 for (n=0;n<nComps;n++) {
257 memcpy(getSampleDataFast(out,n),getSampleDataFast(in,n),numComps_size);
258 }
259
260 } else if (out_data_type == FINLEY_DEGREES_OF_FREEDOM ) {
261 Finley_setError(TYPE_ERROR,"Finley_Assemble_CopyNodalData: cannot copy from reduced degrees of freedom to degrees of freedom.");
262 }
263 }
264 }
265 return;
266 }
267

Properties

Name Value
svn:eol-style native
svn:keywords Author Date Id Revision

  ViewVC Help
Powered by ViewVC 1.1.26