Loading...
Searching...
No Matches
FieldFunctionsM.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-2016 OpenFOAM Foundation
9 Copyright (C) 2019-2023 OpenCFD Ltd.
10-------------------------------------------------------------------------------
11License
12 This file is part of OpenFOAM.
13
14 OpenFOAM is free software: you can redistribute it and/or modify it
15 under the terms of the GNU General Public License as published by
16 the Free Software Foundation, either version 3 of the License, or
17 (at your option) any later version.
18
19 OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
20 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
21 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
22 for more details.
23
24 You should have received a copy of the GNU General Public License
25 along with OpenFOAM. If not, see <http://www.gnu.org/licenses/>.
26
27\*---------------------------------------------------------------------------*/
28
29#include "FieldM.H"
30#include "FieldReuseFunctions.H"
31
32// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
33
34#define UNARY_FUNCTION(ReturnType, Type1, Func) \
35 \
36TEMPLATE \
37void Func \
38( \
39 Field<ReturnType>& result, \
40 const UList<Type1>& f1 \
41) \
42{ \
43 TFOR_ALL_F_OP_FUNC_F(ReturnType, result, =, ::Foam::Func, Type1, f1) \
44} \
45 \
46TEMPLATE \
47tmp<Field<ReturnType>> Func \
48( \
49 const UList<Type1>& f1 \
50) \
51{ \
52 auto tres = tmp<Field<ReturnType>>::New(f1.size()); \
53 Func(tres.ref(), f1); \
54 return tres; \
55} \
56 \
57TEMPLATE \
58tmp<Field<ReturnType>> Func \
59( \
60 const tmp<Field<Type1>>& tf1 \
61) \
62{ \
63 auto tres = reuseTmp<ReturnType, Type1>::New(tf1); \
64 Func(tres.ref(), tf1()); \
65 tf1.clear(); \
66 return tres; \
67}
68
69
70// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
71
72#define UNARY_OPERATOR(ReturnType, Type1, Op, OpFunc) \
73 \
74TEMPLATE \
75void OpFunc \
76( \
77 Field<ReturnType>& result, \
78 const UList<Type1>& f1 \
79) \
80{ \
81 TFOR_ALL_F_OP_OP_F(ReturnType, result, =, Op, Type1, f1) \
82} \
83 \
84TEMPLATE \
85tmp<Field<ReturnType>> operator Op \
86( \
87 const UList<Type1>& f1 \
88) \
89{ \
90 auto tres = tmp<Field<ReturnType>>::New(f1.size()); \
91 OpFunc(tres.ref(), f1); \
92 return tres; \
93} \
94 \
95TEMPLATE \
96tmp<Field<ReturnType>> operator Op \
97( \
98 const tmp<Field<Type1>>& tf1 \
99) \
100{ \
101 auto tres = reuseTmp<ReturnType, Type1>::New(tf1); \
102 OpFunc(tres.ref(), tf1()); \
103 tf1.clear(); \
104 return tres; \
105}
106
107
108// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
109
110#define BINARY_FUNCTION_TRANSFORM(ReturnType, Type1, Type2, Func) \
111 \
112TEMPLATE \
113void Func \
114( \
115 Field<ReturnType>& result, \
116 const UList<Type1>& f1, \
117 const UList<Type2>& f2 \
118) \
119{ \
120 TFOR_ALL_F_OP_FUNC_F_F \
121 ( \
122 ReturnType, result, =, ::Foam::Func, Type1, f1, Type2, f2 \
123 ) \
124}
125
126#define BINARY_FUNCTION_INTERFACE(ReturnType, Type1, Type2, Func) \
127 \
128TEMPLATE \
129tmp<Field<ReturnType>> Func \
130( \
131 const UList<Type1>& f1, \
132 const UList<Type2>& f2 \
133) \
134{ \
135 auto tres = tmp<Field<ReturnType>>::New(f1.size()); \
136 Func(tres.ref(), f1, f2); \
137 return tres; \
138} \
139 \
140TEMPLATE \
141tmp<Field<ReturnType>> Func \
142( \
143 const UList<Type1>& f1, \
144 const tmp<Field<Type2>>& tf2 \
145) \
146{ \
147 auto tres = reuseTmp<ReturnType, Type2>::New(tf2); \
148 Func(tres.ref(), f1, tf2()); \
149 tf2.clear(); \
150 return tres; \
151} \
152 \
153TEMPLATE \
154tmp<Field<ReturnType>> Func \
155( \
156 const tmp<Field<Type1>>& tf1, \
157 const UList<Type2>& f2 \
158) \
159{ \
160 auto tres = reuseTmp<ReturnType, Type1>::New(tf1); \
161 Func(tres.ref(), tf1(), f2); \
162 tf1.clear(); \
163 return tres; \
164} \
165 \
166TEMPLATE \
167tmp<Field<ReturnType>> Func \
168( \
169 const tmp<Field<Type1>>& tf1, \
170 const tmp<Field<Type2>>& tf2 \
171) \
172{ \
173 auto tres = reuseTmpTmp<ReturnType, Type1, Type1, Type2>::New(tf1, tf2); \
174 Func(tres.ref(), tf1(), tf2()); \
175 tf1.clear(); \
176 tf2.clear(); \
177 return tres; \
178}
179
180#define BINARY_FUNCTION(ReturnType, Type1, Type2, Func) \
181 BINARY_FUNCTION_TRANSFORM(ReturnType, Type1, Type2, Func) \
182 BINARY_FUNCTION_INTERFACE(ReturnType, Type1, Type2, Func)
183
184
185// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
186
187#define BINARY_FUNCTION_TRANSFORM_SF(ReturnType, Type1, Type2, Func) \
188 \
189TEMPLATE \
190void Func \
191( \
192 Field<ReturnType>& result, \
193 const Type1& s1, \
194 const UList<Type2>& f2 \
195) \
196{ \
197 TFOR_ALL_F_OP_FUNC_S_F \
198 ( \
199 ReturnType, result, =, ::Foam::Func, Type1, s1, Type2, f2 \
200 ) \
201}
202
203#define BINARY_FUNCTION_INTERFACE_SF(ReturnType, Type1, Type2, Func) \
204 \
205TEMPLATE \
206tmp<Field<ReturnType>> Func \
207( \
208 const Type1& s1, \
209 const UList<Type2>& f2 \
210) \
211{ \
212 auto tres = tmp<Field<ReturnType>>::New(f2.size()); \
213 Func(tres.ref(), s1, f2); \
214 return tres; \
215} \
216 \
217TEMPLATE \
218tmp<Field<ReturnType>> Func \
219( \
220 const Type1& s1, \
221 const tmp<Field<Type2>>& tf2 \
222) \
223{ \
224 auto tres = reuseTmp<ReturnType, Type2>::New(tf2); \
225 Func(tres.ref(), s1, tf2()); \
226 tf2.clear(); \
227 return tres; \
228}
229
230#define BINARY_TYPE_FUNCTION_SF(ReturnType, Type1, Type2, Func) \
231 BINARY_FUNCTION_TRANSFORM_SF(ReturnType, Type1, Type2, Func) \
232 BINARY_FUNCTION_INTERFACE_SF(ReturnType, Type1, Type2, Func)
233
234
235#define BINARY_FUNCTION_TRANSFORM_FS(ReturnType, Type1, Type2, Func) \
236 \
237TEMPLATE \
238void Func \
239( \
240 Field<ReturnType>& result, \
241 const UList<Type1>& f1, \
242 const Type2& s2 \
243) \
244{ \
245 TFOR_ALL_F_OP_FUNC_F_S \
246 ( \
247 ReturnType, result, =, ::Foam::Func, Type1, f1, Type2, s2 \
248 ) \
249}
250
251#define BINARY_FUNCTION_INTERFACE_FS(ReturnType, Type1, Type2, Func) \
252 \
253TEMPLATE \
254tmp<Field<ReturnType>> Func \
255( \
256 const UList<Type1>& f1, \
257 const Type2& s2 \
258) \
259{ \
260 auto tres = tmp<Field<ReturnType>>::New(f1.size()); \
261 Func(tres.ref(), f1, s2); \
262 return tres; \
263} \
264 \
265TEMPLATE \
266tmp<Field<ReturnType>> Func \
267( \
268 const tmp<Field<Type1>>& tf1, \
269 const Type2& s2 \
270) \
271{ \
272 auto tres = reuseTmp<ReturnType, Type1>::New(tf1); \
273 Func(tres.ref(), tf1(), s2); \
274 tf1.clear(); \
275 return tres; \
276}
277
278#define BINARY_TYPE_FUNCTION_FS(ReturnType, Type1, Type2, Func) \
279 BINARY_FUNCTION_TRANSFORM_FS(ReturnType, Type1, Type2, Func) \
280 BINARY_FUNCTION_INTERFACE_FS(ReturnType, Type1, Type2, Func)
281
282
283#define BINARY_TYPE_FUNCTION(ReturnType, Type1, Type2, Func) \
284 BINARY_TYPE_FUNCTION_SF(ReturnType, Type1, Type2, Func) \
285 BINARY_TYPE_FUNCTION_FS(ReturnType, Type1, Type2, Func)
286
287
288// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
289
290#define BINARY_OPERATOR(ReturnType, Type1, Type2, Op, OpFunc) \
291 \
292TEMPLATE \
293void OpFunc \
294( \
295 Field<ReturnType>& result, \
296 const UList<Type1>& f1, \
297 const UList<Type2>& f2 \
298) \
299{ \
300 TFOR_ALL_F_OP_F_OP_F(ReturnType, result, =, Type1, f1, Op, Type2, f2) \
301} \
302 \
303TEMPLATE \
304tmp<Field<ReturnType>> operator Op \
305( \
306 const UList<Type1>& f1, \
307 const UList<Type2>& f2 \
308) \
309{ \
310 auto tres = tmp<Field<ReturnType>>::New(f1.size()); \
311 OpFunc(tres.ref(), f1, f2); \
312 return tres; \
313} \
314 \
315TEMPLATE \
316tmp<Field<ReturnType>> operator Op \
317( \
318 const UList<Type1>& f1, \
319 const tmp<Field<Type2>>& tf2 \
320) \
321{ \
322 auto tres = reuseTmp<ReturnType, Type2>::New(tf2); \
323 OpFunc(tres.ref(), f1, tf2()); \
324 tf2.clear(); \
325 return tres; \
326} \
327 \
328TEMPLATE \
329tmp<Field<ReturnType>> operator Op \
330( \
331 const tmp<Field<Type1>>& tf1, \
332 const UList<Type2>& f2 \
333) \
334{ \
335 auto tres = reuseTmp<ReturnType, Type1>::New(tf1); \
336 OpFunc(tres.ref(), tf1(), f2); \
337 tf1.clear(); \
338 return tres; \
339} \
340 \
341TEMPLATE \
342tmp<Field<ReturnType>> operator Op \
343( \
344 const tmp<Field<Type1>>& tf1, \
345 const tmp<Field<Type2>>& tf2 \
346) \
347{ \
348 auto tres = reuseTmpTmp<ReturnType, Type1, Type1, Type2>::New(tf1, tf2); \
349 OpFunc(tres.ref(), tf1(), tf2()); \
350 tf1.clear(); \
351 tf2.clear(); \
352 return tres; \
353}
354
355
356// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
357
358#define BINARY_TYPE_OPERATOR_SF(ReturnType, Type1, Type2, Op, OpFunc) \
359 \
360TEMPLATE \
361void OpFunc \
362( \
363 Field<ReturnType>& result, \
364 const Type1& s1, \
365 const UList<Type2>& f2 \
366) \
367{ \
368 TFOR_ALL_F_OP_S_OP_F(ReturnType, result, =, Type1, s1, Op, Type2, f2) \
369} \
370 \
371TEMPLATE \
372tmp<Field<ReturnType>> operator Op \
373( \
374 const Type1& s1, \
375 const UList<Type2>& f2 \
376) \
377{ \
378 auto tres = tmp<Field<ReturnType>>::New(f2.size()); \
379 OpFunc(tres.ref(), s1, f2); \
380 return tres; \
381} \
382 \
383TEMPLATE \
384tmp<Field<ReturnType>> operator Op \
385( \
386 const Type1& s1, \
387 const tmp<Field<Type2>>& tf2 \
388) \
389{ \
390 auto tres = reuseTmp<ReturnType, Type2>::New(tf2); \
391 OpFunc(tres.ref(), s1, tf2()); \
392 tf2.clear(); \
393 return tres; \
394}
395
396
397#define BINARY_TYPE_OPERATOR_FS(ReturnType, Type1, Type2, Op, OpFunc) \
398 \
399TEMPLATE \
400void OpFunc \
401( \
402 Field<ReturnType>& result, \
403 const UList<Type1>& f1, \
404 const Type2& s2 \
405) \
406{ \
407 TFOR_ALL_F_OP_F_OP_S(ReturnType, result, =, Type1, f1, Op, Type2, s2) \
408} \
409 \
410TEMPLATE \
411tmp<Field<ReturnType>> operator Op \
412( \
413 const UList<Type1>& f1, \
414 const Type2& s2 \
415) \
416{ \
417 auto tres = tmp<Field<ReturnType>>::New(f1.size()); \
418 OpFunc(tres.ref(), f1, s2); \
419 return tres; \
420} \
421 \
422TEMPLATE \
423tmp<Field<ReturnType>> operator Op \
424( \
425 const tmp<Field<Type1>>& tf1, \
426 const Type2& s2 \
427) \
428{ \
429 auto tres = reuseTmp<ReturnType, Type1>::New(tf1); \
430 OpFunc(tres.ref(), tf1(), s2); \
431 tf1.clear(); \
432 return tres; \
433}
434
435
436#define BINARY_TYPE_OPERATOR(ReturnType, Type1, Type2, Op, OpFunc) \
437 BINARY_TYPE_OPERATOR_SF(ReturnType, Type1, Type2, Op, OpFunc) \
438 BINARY_TYPE_OPERATOR_FS(ReturnType, Type1, Type2, Op, OpFunc)
439
440
441// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
442
443#define TERNARY_FUNCTION(ReturnType, Type1, Type2, Type3, Func) \
444 \
445TEMPLATE \
446void Func \
447( \
448 Field<ReturnType>& result, \
449 const UList<Type1>& f1, \
450 const UList<Type2>& f2, \
451 const UList<Type3>& f3 \
452) \
453{ \
454 TFOR_ALL_F_OP_FUNC_F_F_F \
455 ( \
456 ReturnType, result, =, ::Foam::Func, Type1, f1, Type2, f2, Type3, f3 \
457 ) \
458} \
459 \
460TEMPLATE \
461tmp<Field<ReturnType>> Func \
462( \
463 const UList<Type1>& f1, \
464 const UList<Type2>& f2, \
465 const UList<Type3>& f3 \
466) \
467{ \
468 auto tres = tmp<Field<ReturnType>>::New(f1.size()); \
469 Func(tres.ref(), f1, f2, f3); \
470 return tres; \
471} \
472 \
473TEMPLATE \
474tmp<Field<ReturnType>> Func \
475( \
476 const tmp<Field<Type1>>& tf1, \
477 const UList<Type2>& f2, \
478 const UList<Type3>& f3 \
479) \
480{ \
481 auto tres = reuseTmp<ReturnType, Type1>::New(tf1); \
482 Func(tres.ref(), tf1(), f2, f3); \
483 tf1.clear(); \
484 return tres; \
485} \
486 \
487TEMPLATE \
488tmp<Field<ReturnType>> Func \
489( \
490 const UList<Type1>& f1, \
491 const tmp<Field<Type2>>& tf2, \
492 const UList<Type3>& f3 \
493) \
494{ \
495 auto tres = reuseTmp<ReturnType, Type2>::New(tf2); \
496 Func(tres.ref(), f1, tf2(), f3); \
497 tf2.clear(); \
498 return tres; \
499} \
500 \
501TEMPLATE \
502tmp<Field<ReturnType>> Func \
503( \
504 const UList<Type1>& f1, \
505 const UList<Type2>& f2, \
506 const tmp<Field<Type3>>& tf3 \
507) \
508{ \
509 auto tres = reuseTmp<ReturnType, Type3>::New(tf3); \
510 Func(tres.ref(), f1, f2, tf3()); \
511 tf3.clear(); \
512 return tres; \
513} \
514 \
515TEMPLATE \
516tmp<Field<ReturnType>> Func \
517( \
518 const tmp<Field<Type1>>& tf1, \
519 const tmp<Field<Type2>>& tf2, \
520 const UList<Type3>& f3 \
521) \
522{ \
523 auto tres = reuseTmpTmp<ReturnType, Type1, Type1, Type2>::New(tf1, tf2); \
524 Func(tres.ref(), tf1(), tf2(), f3); \
525 tf1.clear(); \
526 tf2.clear(); \
527 return tres; \
528} \
529 \
530TEMPLATE \
531tmp<Field<ReturnType>> Func \
532( \
533 const tmp<Field<Type1>>& tf1, \
534 const UList<Type2>& f2, \
535 const tmp<Field<Type3>>& tf3 \
536) \
537{ \
538 auto tres = reuseTmpTmp<ReturnType, Type1, Type1, Type3>::New(tf1, tf3); \
539 Func(tres.ref(), tf1(), f2, tf3()); \
540 tf1.clear(); \
541 tf3.clear(); \
542 return tres; \
543} \
544 \
545TEMPLATE \
546tmp<Field<ReturnType>> Func \
547( \
548 const UList<Type1>& f1, \
549 const tmp<Field<Type2>>& tf2, \
550 const tmp<Field<Type3>>& tf3 \
551) \
552{ \
553 auto tres = reuseTmpTmp<ReturnType, Type2, Type2, Type3>::New(tf2, tf3); \
554 Func(tres.ref(), f1, tf2(), tf3()); \
555 tf2.clear(); \
556 tf3.clear(); \
557 return tres; \
558} \
559 \
560TEMPLATE \
561tmp<Field<ReturnType>> Func \
562( \
563 const tmp<Field<Type1>>& tf1, \
564 const tmp<Field<Type2>>& tf2, \
565 const tmp<Field<Type3>>& tf3 \
566) \
567{ \
568 /* TBD: check all three types? */ \
569 auto tres = reuseTmpTmp<ReturnType, Type1, Type1, Type2>::New(tf1, tf2); \
570 Func(tres.ref(), tf1(), tf2(), tf3()); \
571 tf1.clear(); \
572 tf2.clear(); \
573 tf3.clear(); \
574 return tres; \
575}
576
577
578#define TERNARY_TYPE_FUNCTION_FFS(ReturnType, Type1, Type2, Type3, Func) \
579 \
580TEMPLATE \
581void Func \
582( \
583 Field<ReturnType>& result, \
584 const UList<Type1>& f1, \
585 const UList<Type2>& f2, \
586 const Type3& s3 \
587) \
588{ \
589 TFOR_ALL_F_OP_FUNC_F_F_S \
590 ( \
591 ReturnType, result, =, ::Foam::Func, Type1, f1, Type2, f2, Type3, s3 \
592 ) \
593} \
594 \
595TEMPLATE \
596tmp<Field<ReturnType>> Func \
597( \
598 const UList<Type1>& f1, \
599 const UList<Type2>& f2, \
600 const Type3& s3 \
601) \
602{ \
603 auto tres = tmp<Field<ReturnType>>::New(f1.size()); \
604 Func(tres.ref(), f1, f2, s3); \
605 return tres; \
606} \
607 \
608TEMPLATE \
609tmp<Field<ReturnType>> Func \
610( \
611 const tmp<Field<Type1>>& tf1, \
612 const UList<Type2>& f2, \
613 const Type3& s3 \
614) \
615{ \
616 auto tres = reuseTmp<ReturnType, Type1>::New(tf1); \
617 Func(tres.ref(), tf1(), f2, s3); \
618 tf1.clear(); \
619 return tres; \
620} \
621 \
622TEMPLATE \
623tmp<Field<ReturnType>> Func \
624( \
625 const UList<Type1>& f1, \
626 const tmp<Field<Type2>>& tf2, \
627 const Type3& s3 \
628) \
629{ \
630 auto tres = reuseTmp<ReturnType, Type2>::New(tf2); \
631 Func(tres.ref(), f1, tf2(), s3); \
632 tf2.clear(); \
633 return tres; \
634} \
635 \
636TEMPLATE \
637tmp<Field<ReturnType>> Func \
638( \
639 const tmp<Field<Type1>>& tf1, \
640 const tmp<Field<Type2>>& tf2, \
641 const Type3& s3 \
642) \
643{ \
644 auto tres = reuseTmpTmp<ReturnType, Type1, Type1, Type2>::New(tf1, tf2); \
645 Func(tres.ref(), tf1(), tf2(), s3); \
646 tf1.clear(); \
647 tf2.clear(); \
648 return tres; \
649}
650
651
652// ************************************************************************* //
FieldM.H
Declaration macros for Field<Type> algebra.