FieldFieldFunctionsM.C
Go to the documentation of this file.
1/*---------------------------------------------------------------------------*\
2 ========= |
3 \\ / F ield | OpenFOAM: The Open Source CFD Toolbox
4 \\ / O peration |
5 \\ / A nd | www.openfoam.com
6 \\/ M anipulation |
7-------------------------------------------------------------------------------
8 Copyright (C) 2011-2017 OpenFOAM Foundation
9-------------------------------------------------------------------------------
10License
11 This file is part of OpenFOAM.
12
13 OpenFOAM is free software: you can redistribute it and/or modify it
14 under the terms of the GNU General Public License as published by
15 the Free Software Foundation, either version 3 of the License, or
16 (at your option) any later version.
17
18 OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
19 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
20 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
21 for more details.
22
23 You should have received a copy of the GNU General Public License
24 along with OpenFOAM. If not, see <http://www.gnu.org/licenses/>.
25
26\*---------------------------------------------------------------------------*/
27
28#include "FieldM.H"
29#include "FieldFieldReuseFunctions.H"
30
31// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
32
33#define UNARY_FUNCTION(ReturnType, Type, Func) \
34 \
35TEMPLATE \
36void Func \
37( \
38 FieldField<Field, ReturnType>& res, \
39 const FieldField<Field, Type>& f \
40) \
41{ \
42 forAll(res, i) \
43 { \
44 Func(res[i], f[i]); \
45 } \
46} \
47 \
48TEMPLATE \
49tmp<FieldField<Field, ReturnType>> Func \
50( \
51 const FieldField<Field, Type>& f \
52) \
53{ \
54 tmp<FieldField<Field, ReturnType>> tres \
55 ( \
56 FieldField<Field, ReturnType>::NewCalculatedType(f) \
57 ); \
58 Func(tres.ref(), f); \
59 return tres; \
60} \
61 \
62TEMPLATE \
63tmp<FieldField<Field, ReturnType>> Func \
64( \
65 const tmp<FieldField<Field, Type>>& tf \
66) \
67{ \
68 tmp<FieldField<Field, ReturnType>> tres(New(tf)); \
69 Func(tres.ref(), tf()); \
70 tf.clear(); \
71 return tres; \
72}
73
74
75// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
76
77#define UNARY_OPERATOR(ReturnType, Type, Op, OpFunc) \
78 \
79TEMPLATE \
80void OpFunc \
81( \
82 FieldField<Field, ReturnType>& res, \
83 const FieldField<Field, Type>& f \
84) \
85{ \
86 forAll(res, i) \
87 { \
88 OpFunc(res[i], f[i]); \
89 } \
90} \
91 \
92TEMPLATE \
93tmp<FieldField<Field, ReturnType>> operator Op \
94( \
95 const FieldField<Field, Type>& f \
96) \
97{ \
98 tmp<FieldField<Field, ReturnType>> tres \
99 ( \
100 FieldField<Field, Type>::NewCalculatedType(f) \
101 ); \
102 OpFunc(tres.ref(), f); \
103 return tres; \
104} \
105 \
106TEMPLATE \
107tmp<FieldField<Field, ReturnType>> operator Op \
108( \
109 const tmp<FieldField<Field, Type>>& tf \
110) \
111{ \
112 tmp<FieldField<Field, ReturnType>> tres(New(tf)); \
113 OpFunc(tres.ref(), tf()); \
114 tf.clear(); \
115 return tres; \
116}
117
118
119// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
120
121#define BINARY_FUNCTION(ReturnType, Type1, Type2, Func) \
122 \
123TEMPLATE \
124void Func \
125( \
126 FieldField<Field, ReturnType>& f, \
127 const FieldField<Field, Type1>& f1, \
128 const FieldField<Field, Type2>& f2 \
129) \
130{ \
131 forAll(f, i) \
132 { \
133 Func(f[i], f1[i], f2[i]); \
134 } \
135} \
136 \
137TEMPLATE \
138tmp<FieldField<Field, ReturnType>> Func \
139( \
140 const FieldField<Field, Type1>& f1, \
141 const FieldField<Field, Type2>& f2 \
142) \
143{ \
144 tmp<FieldField<Field, ReturnType>> tres \
145 ( \
146 FieldField<Field, Type1>::NewCalculatedType(f1) \
147 ); \
148 Func(tres.ref(), f1, f2); \
149 return tres; \
150} \
151 \
152TEMPLATE \
153tmp<FieldField<Field, ReturnType>> Func \
154( \
155 const FieldField<Field, Type1>& f1, \
156 const tmp<FieldField<Field, Type2>>& tf2 \
157) \
158{ \
159 tmp<FieldField<Field, ReturnType>> tres \
160 ( \
161 reuseTmpFieldField<Field, ReturnType, Type2>::New(tf2) \
162 ); \
163 Func(tres.ref(), f1, tf2()); \
164 tf2.clear(); \
165 return tres; \
166} \
167 \
168TEMPLATE \
169tmp<FieldField<Field, ReturnType>> Func \
170( \
171 const tmp<FieldField<Field, Type1>>& tf1, \
172 const FieldField<Field, Type2>& f2 \
173) \
174{ \
175 tmp<FieldField<Field, ReturnType>> tres \
176 ( \
177 reuseTmpFieldField<Field, ReturnType, Type1>::New(tf1) \
178 ); \
179 Func(tres.ref(), tf1(), f2); \
180 tf1.clear(); \
181 return tres; \
182} \
183 \
184TEMPLATE \
185tmp<FieldField<Field, ReturnType>> Func \
186( \
187 const tmp<FieldField<Field, Type1>>& tf1, \
188 const tmp<FieldField<Field, Type2>>& tf2 \
189) \
190{ \
191 tmp<FieldField<Field, ReturnType>> tres \
192 ( \
193 reuseTmpTmpFieldField<Field, ReturnType, Type1, Type1, Type2>:: \
194 New(tf1, tf2) \
195 ); \
196 Func(tres.ref(), tf1(), tf2()); \
197 tf1.clear(); \
198 tf2.clear(); \
199 return tres; \
200}
201
202
203// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
204
205#define BINARY_TYPE_FUNCTION_SF(ReturnType, Type1, Type2, Func) \
206 \
207TEMPLATE \
208void Func \
209( \
210 FieldField<Field, ReturnType>& f, \
211 const Type1& s, \
212 const FieldField<Field, Type2>& f2 \
213) \
214{ \
215 forAll(f, i) \
216 { \
217 Func(f[i], s, f2[i]); \
218 } \
219} \
220 \
221TEMPLATE \
222tmp<FieldField<Field, ReturnType>> Func \
223( \
224 const Type1& s, \
225 const FieldField<Field, Type2>& f2 \
226) \
227{ \
228 tmp<FieldField<Field, ReturnType>> tres \
229 ( \
230 FieldField<Field, Type2>::NewCalculatedType(f2) \
231 ); \
232 Func(tres.ref(), s, f2); \
233 return tres; \
234} \
235 \
236TEMPLATE \
237tmp<FieldField<Field, ReturnType>> Func \
238( \
239 const Type1& s, \
240 const tmp<FieldField<Field, Type2>>& tf2 \
241) \
242{ \
243 tmp<FieldField<Field, ReturnType>> tres \
244 ( \
245 reuseTmpFieldField<Field, ReturnType, Type2>::New(tf2) \
246 ); \
247 Func(tres.ref(), s, tf2()); \
248 tf2.clear(); \
249 return tres; \
250}
251
252
253#define BINARY_TYPE_FUNCTION_FS(ReturnType, Type1, Type2, Func) \
254 \
255TEMPLATE \
256void Func \
257( \
258 FieldField<Field, ReturnType>& f, \
259 const FieldField<Field, Type1>& f1, \
260 const Type2& s \
261) \
262{ \
263 forAll(f, i) \
264 { \
265 Func(f[i], f1[i], s); \
266 } \
267} \
268 \
269TEMPLATE \
270tmp<FieldField<Field, ReturnType>> Func \
271( \
272 const FieldField<Field, Type1>& f1, \
273 const Type2& s \
274) \
275{ \
276 tmp<FieldField<Field, ReturnType>> tres \
277 ( \
278 FieldField<Field, Type1>::NewCalculatedType(f1) \
279 ); \
280 Func(tres.ref(), f1, s); \
281 return tres; \
282} \
283 \
284TEMPLATE \
285tmp<FieldField<Field, ReturnType>> Func \
286( \
287 const tmp<FieldField<Field, Type1>>& tf1, \
288 const Type2& s \
289) \
290{ \
291 tmp<FieldField<Field, ReturnType>> tres \
292 ( \
293 reuseTmpFieldField<Field, ReturnType, Type1>::New(tf1) \
294 ); \
295 Func(tres.ref(), tf1(), s); \
296 tf1.clear(); \
297 return tres; \
298}
299
300
301#define BINARY_TYPE_FUNCTION(ReturnType, Type1, Type2, Func) \
302 BINARY_TYPE_FUNCTION_SF(ReturnType, Type1, Type2, Func) \
303 BINARY_TYPE_FUNCTION_FS(ReturnType, Type1, Type2, Func)
304
305
306// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
307
308#define BINARY_OPERATOR(ReturnType, Type1, Type2, Op, OpFunc) \
309 \
310TEMPLATE \
311void OpFunc \
312( \
313 FieldField<Field, ReturnType>& f, \
314 const FieldField<Field, Type1>& f1, \
315 const FieldField<Field, Type2>& f2 \
316) \
317{ \
318 forAll(f, i) \
319 { \
320 OpFunc(f[i], f1[i], f2[i]); \
321 } \
322} \
323 \
324TEMPLATE \
325tmp<FieldField<Field, ReturnType>> operator Op \
326( \
327 const FieldField<Field, Type1>& f1, \
328 const FieldField<Field, Type2>& f2 \
329) \
330{ \
331 tmp<FieldField<Field, ReturnType>> tres \
332 ( \
333 FieldField<Field, ReturnType>::NewCalculatedType(f1) \
334 ); \
335 OpFunc(tres.ref(), f1, f2); \
336 return tres; \
337} \
338 \
339TEMPLATE \
340tmp<FieldField<Field, ReturnType>> operator Op \
341( \
342 const FieldField<Field, Type1>& f1, \
343 const tmp<FieldField<Field, Type2>>& tf2 \
344) \
345{ \
346 tmp<FieldField<Field, ReturnType>> tres \
347 ( \
348 reuseTmpFieldField<Field, ReturnType, Type2>::New(tf2) \
349 ); \
350 OpFunc(tres.ref(), f1, tf2()); \
351 tf2.clear(); \
352 return tres; \
353} \
354 \
355TEMPLATE \
356tmp<FieldField<Field, ReturnType>> operator Op \
357( \
358 const tmp<FieldField<Field, Type1>>& tf1, \
359 const FieldField<Field, Type2>& f2 \
360) \
361{ \
362 tmp<FieldField<Field, ReturnType>> tres \
363 ( \
364 reuseTmpFieldField<Field, ReturnType, Type1>::New(tf1) \
365 ); \
366 OpFunc(tres.ref(), tf1(), f2); \
367 tf1.clear(); \
368 return tres; \
369} \
370 \
371TEMPLATE \
372tmp<FieldField<Field, ReturnType>> operator Op \
373( \
374 const tmp<FieldField<Field, Type1>>& tf1, \
375 const tmp<FieldField<Field, Type2>>& tf2 \
376) \
377{ \
378 tmp<FieldField<Field, ReturnType>> tres \
379 ( \
380 reuseTmpTmpFieldField<Field, ReturnType, Type1, Type1, Type2>:: \
381 New(tf1, tf2) \
382 ); \
383 OpFunc(tres.ref(), tf1(), tf2()); \
384 tf1.clear(); \
385 tf2.clear(); \
386 return tres; \
387}
388
389
390// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
391
392#define BINARY_TYPE_OPERATOR_SF(ReturnType, Type1, Type2, Op, OpFunc) \
393 \
394TEMPLATE \
395void OpFunc \
396( \
397 FieldField<Field, ReturnType>& f, \
398 const Type1& s, \
399 const FieldField<Field, Type2>& f2 \
400) \
401{ \
402 forAll(f, i) \
403 { \
404 OpFunc(f[i], s, f2[i]); \
405 } \
406} \
407 \
408TEMPLATE \
409tmp<FieldField<Field, ReturnType>> operator Op \
410( \
411 const Type1& s, \
412 const FieldField<Field, Type2>& f2 \
413) \
414{ \
415 tmp<FieldField<Field, ReturnType>> tres \
416 ( \
417 FieldField<Field, Type2>::NewCalculatedType(f2) \
418 ); \
419 OpFunc(tres.ref(), s, f2); \
420 return tres; \
421} \
422 \
423TEMPLATE \
424tmp<FieldField<Field, ReturnType>> operator Op \
425( \
426 const Type1& s, \
427 const tmp<FieldField<Field, Type2>>& tf2 \
428) \
429{ \
430 tmp<FieldField<Field, ReturnType>> tres \
431 ( \
432 reuseTmpFieldField<Field, ReturnType, Type2>::New(tf2) \
433 ); \
434 OpFunc(tres.ref(), s, tf2()); \
435 tf2.clear(); \
436 return tres; \
437}
438
439
440#define BINARY_TYPE_OPERATOR_FS(ReturnType, Type1, Type2, Op, OpFunc) \
441 \
442TEMPLATE \
443void OpFunc \
444( \
445 FieldField<Field, ReturnType>& f, \
446 const FieldField<Field, Type1>& f1, \
447 const Type2& s \
448) \
449{ \
450 forAll(f, i) \
451 { \
452 OpFunc(f[i], f1[i], s); \
453 } \
454} \
455 \
456TEMPLATE \
457tmp<FieldField<Field, ReturnType>> operator Op \
458( \
459 const FieldField<Field, Type1>& f1, \
460 const Type2& s \
461) \
462{ \
463 tmp<FieldField<Field, ReturnType>> tres \
464 ( \
465 FieldField<Field, Type1>::NewCalculatedType(f1) \
466 ); \
467 OpFunc(tres.ref(), f1, s); \
468 return tres; \
469} \
470 \
471TEMPLATE \
472tmp<FieldField<Field, ReturnType>> operator Op \
473( \
474 const tmp<FieldField<Field, Type1>>& tf1, \
475 const Type2& s \
476) \
477{ \
478 tmp<FieldField<Field, ReturnType>> tres \
479 ( \
480 reuseTmpFieldField<Field, ReturnType, Type1>::New(tf1) \
481 ); \
482 OpFunc(tres.ref(), tf1(), s); \
483 tf1.clear(); \
484 return tres; \
485}
486
487
488#define BINARY_TYPE_OPERATOR(ReturnType, Type1, Type2, Op, OpFunc) \
489 BINARY_TYPE_OPERATOR_SF(ReturnType, Type1, Type2, Op, OpFunc) \
490 BINARY_TYPE_OPERATOR_FS(ReturnType, Type1, Type2, Op, OpFunc)
491
492// ************************************************************************* //
FieldM.H
High performance macro functions for Field<Type> algebra. These expand using either array element acc...