Loading...
Searching...
No Matches
DimensionedFieldFunctionsM.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 "DimensionedFieldReuseFunctions.H"
30
31// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
32
33#define UNARY_FUNCTION(ReturnType, Type1, Func, Dfunc) \
34 \
35TEMPLATE \
36void Func \
37( \
38 DimensionedField<ReturnType, GeoMesh>& result, \
39 const DimensionedField<Type1, GeoMesh>& f1 \
40) \
41{ \
42 /* TBD: reset dimensions? */ \
43 Func(result.field(), f1.field()); \
44 result.oriented() = Dfunc(f1.oriented()); \
45} \
46 \
47TEMPLATE \
48tmp<DimensionedField<ReturnType, GeoMesh>> Func \
49( \
50 const DimensionedField<Type1, GeoMesh>& f1 \
51) \
52{ \
53 auto tres = \
54 reuseTmpDimensionedField<ReturnType, Type1, GeoMesh>::New \
55 ( \
56 f1, \
57 #Func "(" + f1.name() + ')', \
58 Dfunc(f1.dimensions()) \
59 ); \
60 \
61 Foam::Func(tres.ref(), f1); \
62 return tres; \
63} \
64 \
65 \
66TEMPLATE \
67tmp<DimensionedField<ReturnType, GeoMesh>> Func \
68( \
69 const tmp<DimensionedField<Type1, GeoMesh>>& tf1 \
70) \
71{ \
72 const auto& f1 = tf1(); \
73 \
74 auto tres = \
75 reuseTmpDimensionedField<ReturnType, Type1, GeoMesh>::New \
76 ( \
77 tf1, \
78 #Func "(" + f1.name() + ')', \
79 Dfunc(f1.dimensions()) \
80 ); \
81 \
82 Foam::Func(tres.ref(), f1); \
83 tf1.clear(); \
84 return tres; \
85}
86
87
88// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
89
90#define UNARY_OPERATOR(ReturnType, Type1, Op, OpFunc, Dfunc) \
91 \
92TEMPLATE \
93void OpFunc \
94( \
95 DimensionedField<ReturnType, GeoMesh>& result, \
96 const DimensionedField<Type1, GeoMesh>& f1 \
97) \
98{ \
99 /* TBD: reset dimensions? */ \
100 Foam::OpFunc(result.field(), f1.field()); \
101 result.oriented() = Dfunc(f1.oriented()); \
102} \
103 \
104TEMPLATE \
105tmp<DimensionedField<ReturnType, GeoMesh>> operator Op \
106( \
107 const DimensionedField<Type1, GeoMesh>& f1 \
108) \
109{ \
110 auto tres = \
111 reuseTmpDimensionedField<ReturnType, Type1, GeoMesh>::New \
112 ( \
113 f1, \
114 #Op + f1.name(), \
115 Dfunc(f1.dimensions()) \
116 ); \
117 \
118 Foam::OpFunc(tres.ref(), f1); \
119 return tres; \
120} \
121 \
122 \
123TEMPLATE \
124tmp<DimensionedField<ReturnType, GeoMesh>> operator Op \
125( \
126 const tmp<DimensionedField<Type1, GeoMesh>>& tf1 \
127) \
128{ \
129 const auto& f1 = tf1(); \
130 \
131 auto tres = \
132 reuseTmpDimensionedField<ReturnType, Type1, GeoMesh>::New \
133 ( \
134 tf1, \
135 #Op + f1.name(), \
136 Dfunc(f1.dimensions()) \
137 ); \
138 \
139 Foam::OpFunc(tres.ref(), f1); \
140 tf1.clear(); \
141 return tres; \
142}
143
144
145// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
146
147#define BINARY_FUNCTION(ReturnType, Type1, Type2, Func) \
148 \
149TEMPLATE \
150void Func \
151( \
152 DimensionedField<ReturnType, GeoMesh>& result, \
153 const DimensionedField<Type1, GeoMesh>& f1, \
154 const DimensionedField<Type2, GeoMesh>& f2 \
155) \
156{ \
157 /* TBD: reset dimensions? */ \
158 Foam::Func(result.field(), f1.field(), f2.field()); \
159 result.oriented() = Func(f1.oriented(), f2.oriented()); \
160} \
161 \
162TEMPLATE \
163tmp<DimensionedField<ReturnType, GeoMesh>> Func \
164( \
165 const DimensionedField<Type1, GeoMesh>& f1, \
166 const DimensionedField<Type2, GeoMesh>& f2 \
167) \
168{ \
169 auto tres = \
170 reuseTmpDimensionedField<ReturnType, Type1, GeoMesh>::New \
171 ( \
172 f1, \
173 #Func "(" + f1.name() + ',' + f2.name() + ')', \
174 Func(f1.dimensions(), f2.dimensions()) \
175 ); \
176 \
177 Foam::Func(tres.ref(), f1, f2); \
178 return tres; \
179} \
180 \
181 \
182TEMPLATE \
183tmp<DimensionedField<ReturnType, GeoMesh>> Func \
184( \
185 const DimensionedField<Type1, GeoMesh>& f1, \
186 const tmp<DimensionedField<Type2, GeoMesh>>& tf2 \
187) \
188{ \
189 const auto& f2 = tf2(); \
190 \
191 auto tres = \
192 reuseTmpDimensionedField<ReturnType, Type2, GeoMesh>::New \
193 ( \
194 tf2, \
195 #Func "(" + f1.name() + ',' + f2.name() + ')', \
196 Func(f1.dimensions(), f2.dimensions()) \
197 ); \
198 \
199 Foam::Func(tres.ref(), f1, f2); \
200 tf2.clear(); \
201 return tres; \
202} \
203 \
204 \
205TEMPLATE \
206tmp<DimensionedField<ReturnType, GeoMesh>> Func \
207( \
208 const tmp<DimensionedField<Type1, GeoMesh>>& tf1, \
209 const DimensionedField<Type2, GeoMesh>& f2 \
210) \
211{ \
212 const auto& f1 = tf1(); \
213 \
214 auto tres = \
215 reuseTmpDimensionedField<ReturnType, Type1, GeoMesh>::New \
216 ( \
217 tf1, \
218 #Func "(" + f1.name() + ',' + f2.name() + ')', \
219 Func(f1.dimensions(), f2.dimensions()) \
220 ); \
221 \
222 Foam::Func(tres.ref(), f1, f2); \
223 tf1.clear(); \
224 return tres; \
225} \
226 \
227 \
228TEMPLATE \
229tmp<DimensionedField<ReturnType, GeoMesh>> Func \
230( \
231 const tmp<DimensionedField<Type1, GeoMesh>>& tf1, \
232 const tmp<DimensionedField<Type2, GeoMesh>>& tf2 \
233) \
234{ \
235 const auto& f1 = tf1(); \
236 const auto& f2 = tf2(); \
237 \
238 auto tres = \
239 reuseTmpTmpDimensionedField \
240 <ReturnType, Type1, Type1, Type2, GeoMesh>::New \
241 ( \
242 tf1, \
243 tf2, \
244 #Func "(" + f1.name() + ',' + f2.name() + ')', \
245 Func(f1.dimensions(), f2.dimensions()) \
246 ); \
247 \
248 Foam::Func(tres.ref(), f1, f2); \
249 tf1.clear(); \
250 tf2.clear(); \
251 return tres; \
252}
253
254
255// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
256
257#define BINARY_TYPE_FUNCTION_SF(ReturnType, Type1, Type2, Func) \
258 \
259TEMPLATE \
260void Func \
261( \
262 DimensionedField<ReturnType, GeoMesh>& result, \
263 const dimensioned<Type1>& dt1, \
264 const DimensionedField<Type2, GeoMesh>& f2 \
265) \
266{ \
267 /* TBD: reset dimensions? */ \
268 Func(result.field(), dt1.value(), f2.field()); \
269 result.oriented() = f2.oriented(); \
270} \
271 \
272TEMPLATE \
273tmp<DimensionedField<ReturnType, GeoMesh>> Func \
274( \
275 const dimensioned<Type1>& dt1, \
276 const DimensionedField<Type2, GeoMesh>& f2 \
277) \
278{ \
279 auto tres = \
280 reuseTmpDimensionedField<ReturnType, Type2, GeoMesh>::New \
281 ( \
282 f2, \
283 #Func "(" + dt1.name() + ',' + f2.name() + ')', \
284 Func(dt1.dimensions(), f2.dimensions()) \
285 ); \
286 \
287 Foam::Func(tres.ref(), dt1, f2); \
288 return tres; \
289} \
290 \
291 \
292TEMPLATE \
293tmp<DimensionedField<ReturnType, GeoMesh>> Func \
294( \
295 const Type1& s1, \
296 const DimensionedField<Type2, GeoMesh>& f2 \
297) \
298{ \
299 return Foam::Func(dimensioned<Type1>(s1), f2); \
300} \
301 \
302 \
303TEMPLATE \
304tmp<DimensionedField<ReturnType, GeoMesh>> Func \
305( \
306 const dimensioned<Type1>& dt1, \
307 const tmp<DimensionedField<Type2, GeoMesh>>& tf2 \
308) \
309{ \
310 const auto& f2 = tf2(); \
311 \
312 auto tres = \
313 reuseTmpDimensionedField<ReturnType, Type2, GeoMesh>::New \
314 ( \
315 tf2, \
316 #Func "(" + dt1.name() + ',' + f2.name() + ')', \
317 Func(dt1.dimensions(), f2.dimensions()) \
318 ); \
319 \
320 Foam::Func(tres.ref(), dt1, f2); \
321 tf2.clear(); \
322 return tres; \
323} \
324 \
325TEMPLATE \
326tmp<DimensionedField<ReturnType, GeoMesh>> Func \
327( \
328 const Type1& s1, \
329 const tmp<DimensionedField<Type2, GeoMesh>>& tf2 \
330) \
331{ \
332 return Foam::Func(dimensioned<Type2>(s1), tf2); \
333}
334
335
336#define BINARY_TYPE_FUNCTION_FS(ReturnType, Type1, Type2, Func) \
337 \
338TEMPLATE \
339void Func \
340( \
341 DimensionedField<ReturnType, GeoMesh>& result, \
342 const DimensionedField<Type1, GeoMesh>& f1, \
343 const dimensioned<Type2>& dt2 \
344) \
345{ \
346 /* TBD: reset dimensions? */ \
347 Func(result.field(), f1.field(), dt2.value()); \
348 result.oriented() = f1.oriented(); \
349} \
350 \
351TEMPLATE \
352tmp<DimensionedField<ReturnType, GeoMesh>> Func \
353( \
354 const DimensionedField<Type1, GeoMesh>& f1, \
355 const dimensioned<Type2>& dt2 \
356) \
357{ \
358 auto tres = \
359 reuseTmpDimensionedField<ReturnType, Type1, GeoMesh>::New \
360 ( \
361 f1, \
362 #Func "(" + f1.name() + ',' + dt2.name() + ')', \
363 Func(f1.dimensions(), dt2.dimensions()) \
364 ); \
365 \
366 Foam::Func(tres.ref(), f1, dt2); \
367 return tres; \
368} \
369 \
370 \
371TEMPLATE \
372tmp<DimensionedField<ReturnType, GeoMesh>> Func \
373( \
374 const DimensionedField<Type1, GeoMesh>& f1, \
375 const Type2& s2 \
376) \
377{ \
378 return Foam::Func(f1, dimensioned<Type2>(s2)); \
379} \
380 \
381 \
382TEMPLATE \
383tmp<DimensionedField<ReturnType, GeoMesh>> Func \
384( \
385 const tmp<DimensionedField<Type1, GeoMesh>>& tf1, \
386 const dimensioned<Type2>& dt2 \
387) \
388{ \
389 const auto& f1 = tf1(); \
390 \
391 auto tres = \
392 reuseTmpDimensionedField<ReturnType, Type1, GeoMesh>::New \
393 ( \
394 tf1, \
395 #Func "(" + f1.name() + ',' + dt2.name() + ')', \
396 Func(f1.dimensions(), dt2.dimensions()) \
397 ); \
398 \
399 Foam::Func(tres.ref(), f1, dt2); \
400 tf1.clear(); \
401 return tres; \
402} \
403 \
404 \
405TEMPLATE \
406tmp<DimensionedField<ReturnType, GeoMesh>> Func \
407( \
408 const tmp<DimensionedField<Type1, GeoMesh>>& tf1, \
409 const Type2& s2 \
410) \
411{ \
412 return Foam::Func(tf1, dimensioned<Type2>(s2)); \
413}
414
415
416#define BINARY_TYPE_FUNCTION(ReturnType, Type1, Type2, Func) \
417 BINARY_TYPE_FUNCTION_SF(ReturnType, Type1, Type2, Func) \
418 BINARY_TYPE_FUNCTION_FS(ReturnType, Type1, Type2, Func)
419
420
421// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
422
423#define BINARY_OPERATOR(ReturnType, Type1, Type2, Op, OpName, OpFunc) \
424 \
425TEMPLATE \
426void OpFunc \
427( \
428 DimensionedField<ReturnType, GeoMesh>& result, \
429 const DimensionedField<Type1, GeoMesh>& f1, \
430 const DimensionedField<Type2, GeoMesh>& f2 \
431) \
432{ \
433 /* TBD: reset dimensions? */ \
434 Foam::OpFunc(result.field(), f1.field(), f2.field()); \
435 result.oriented() = f1.oriented() Op f2.oriented(); \
436} \
437 \
438 \
439TEMPLATE \
440tmp<DimensionedField<ReturnType, GeoMesh>> operator Op \
441( \
442 const DimensionedField<Type1, GeoMesh>& f1, \
443 const DimensionedField<Type2, GeoMesh>& f2 \
444) \
445{ \
446 auto tres = \
447 reuseTmpDimensionedField<ReturnType, Type1, GeoMesh>::New \
448 ( \
449 f1, \
450 '(' + f1.name() + OpName + f2.name() + ')', \
451 (f1.dimensions() Op f2.dimensions()) \
452 ); \
453 \
454 Foam::OpFunc(tres.ref(), f1, f2); \
455 return tres; \
456} \
457 \
458 \
459TEMPLATE \
460tmp<DimensionedField<ReturnType, GeoMesh>> operator Op \
461( \
462 const DimensionedField<Type1, GeoMesh>& f1, \
463 const tmp<DimensionedField<Type2, GeoMesh>>& tf2 \
464) \
465{ \
466 const auto& f2 = tf2(); \
467 \
468 auto tres = \
469 reuseTmpDimensionedField<ReturnType, Type2, GeoMesh>::New \
470 ( \
471 tf2, \
472 '(' + f1.name() + OpName + f2.name() + ')', \
473 (f1.dimensions() Op f2.dimensions()) \
474 ); \
475 \
476 Foam::OpFunc(tres.ref(), f1, f2); \
477 tf2.clear(); \
478 return tres; \
479} \
480 \
481 \
482TEMPLATE \
483tmp<DimensionedField<ReturnType, GeoMesh>> operator Op \
484( \
485 const tmp<DimensionedField<Type1, GeoMesh>>& tf1, \
486 const DimensionedField<Type2, GeoMesh>& f2 \
487) \
488{ \
489 const auto& f1 = tf1(); \
490 \
491 auto tres = \
492 reuseTmpDimensionedField<ReturnType, Type1, GeoMesh>::New \
493 ( \
494 tf1, \
495 '(' + f1.name() + OpName + f2.name() + ')', \
496 (f1.dimensions() Op f2.dimensions()) \
497 ); \
498 \
499 Foam::OpFunc(tres.ref(), f1, f2); \
500 tf1.clear(); \
501 return tres; \
502} \
503 \
504TEMPLATE \
505tmp<DimensionedField<ReturnType, GeoMesh>> operator Op \
506( \
507 const tmp<DimensionedField<Type1, GeoMesh>>& tf1, \
508 const tmp<DimensionedField<Type2, GeoMesh>>& tf2 \
509) \
510{ \
511 const auto& f1 = tf1(); \
512 const auto& f2 = tf2(); \
513 \
514 auto tres = \
515 reuseTmpTmpDimensionedField \
516 <ReturnType, Type1, Type1, Type2, GeoMesh>::New \
517 ( \
518 tf1, \
519 tf2, \
520 '(' + f1.name() + OpName + f2.name() + ')', \
521 f1.dimensions() Op f2.dimensions() \
522 ); \
523 \
524 Foam::OpFunc(tres.ref(), f1, f2); \
525 tf1.clear(); \
526 tf2.clear(); \
527 return tres; \
528}
529
530
531// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
532
533#define BINARY_TYPE_OPERATOR_SF(ReturnType, Type1, Type2, Op, OpName, OpFunc) \
534 \
535TEMPLATE \
536void OpFunc \
537( \
538 DimensionedField<ReturnType, GeoMesh>& result, \
539 const dimensioned<Type1>& dt1, \
540 const DimensionedField<Type2, GeoMesh>& f2 \
541) \
542{ \
543 /* TBD: reset dimensions? */ \
544 Foam::OpFunc(result.field(), dt1.value(), f2.field()); \
545 result.oriented() = f2.oriented(); \
546} \
547 \
548TEMPLATE \
549tmp<DimensionedField<ReturnType, GeoMesh>> operator Op \
550( \
551 const dimensioned<Type1>& dt1, \
552 const DimensionedField<Type2, GeoMesh>& f2 \
553) \
554{ \
555 auto tres = \
556 reuseTmpDimensionedField<ReturnType, Type2, GeoMesh>::New \
557 ( \
558 f2, \
559 '(' + dt1.name() + OpName + f2.name() + ')', \
560 (dt1.dimensions() Op f2.dimensions()) \
561 ); \
562 \
563 Foam::OpFunc(tres.ref(), dt1, f2); \
564 return tres; \
565} \
566 \
567 \
568TEMPLATE \
569tmp<DimensionedField<ReturnType, GeoMesh>> operator Op \
570( \
571 const Type1& s1, \
572 const DimensionedField<Type2, GeoMesh>& f2 \
573) \
574{ \
575 return dimensioned<Type1>(s1) Op f2; \
576} \
577 \
578 \
579TEMPLATE \
580tmp<DimensionedField<ReturnType, GeoMesh>> operator Op \
581( \
582 const dimensioned<Type1>& dt1, \
583 const tmp<DimensionedField<Type2, GeoMesh>>& tf2 \
584) \
585{ \
586 const auto& f2 = tf2(); \
587 \
588 auto tres = \
589 reuseTmpDimensionedField<ReturnType, Type2, GeoMesh>::New \
590 ( \
591 tf2, \
592 '(' + dt1.name() + OpName + f2.name() + ')', \
593 (dt1.dimensions() Op f2.dimensions()) \
594 ); \
595 \
596 Foam::OpFunc(tres.ref(), dt1, f2); \
597 tf2.clear(); \
598 return tres; \
599} \
600 \
601 \
602TEMPLATE \
603tmp<DimensionedField<ReturnType, GeoMesh>> operator Op \
604( \
605 const Type1& s1, \
606 const tmp<DimensionedField<Type2, GeoMesh>>& tf2 \
607) \
608{ \
609 return dimensioned<Type1>(s1) Op tf2; \
610}
611
612
613#define BINARY_TYPE_OPERATOR_FS(ReturnType, Type1, Type2, Op, OpName, OpFunc) \
614 \
615TEMPLATE \
616void OpFunc \
617( \
618 DimensionedField<ReturnType, GeoMesh>& result, \
619 const DimensionedField<Type1, GeoMesh>& f1, \
620 const dimensioned<Type2>& dt2 \
621) \
622{ \
623 /* TBD: reset dimensions? */ \
624 Foam::OpFunc(result.field(), f1.field(), dt2.value()); \
625 result.oriented() = f1.oriented(); \
626} \
627 \
628TEMPLATE \
629tmp<DimensionedField<ReturnType, GeoMesh>> operator Op \
630( \
631 const DimensionedField<Type1, GeoMesh>& f1, \
632 const dimensioned<Type2>& dt2 \
633) \
634{ \
635 auto tres = \
636 reuseTmpDimensionedField<ReturnType, Type1, GeoMesh>::New \
637 ( \
638 f1, \
639 '(' + f1.name() + OpName + dt2.name() + ')', \
640 (f1.dimensions() Op dt2.dimensions()) \
641 ); \
642 \
643 Foam::OpFunc(tres.ref(), f1, dt2); \
644 return tres; \
645} \
646 \
647 \
648TEMPLATE \
649tmp<DimensionedField<ReturnType, GeoMesh>> operator Op \
650( \
651 const DimensionedField<Type1, GeoMesh>& f1, \
652 const Type2& s2 \
653) \
654{ \
655 return f1 Op dimensioned<Type2>(s2); \
656} \
657 \
658 \
659TEMPLATE \
660tmp<DimensionedField<ReturnType, GeoMesh>> operator Op \
661( \
662 const tmp<DimensionedField<Type1, GeoMesh>>& tf1, \
663 const dimensioned<Type2>& dt2 \
664) \
665{ \
666 const auto& f1 = tf1(); \
667 \
668 auto tres = \
669 reuseTmpDimensionedField<ReturnType, Type1, GeoMesh>::New \
670 ( \
671 tf1, \
672 '(' + f1.name() + OpName + dt2.name() + ')', \
673 (f1.dimensions() Op dt2.dimensions()) \
674 ); \
675 \
676 Foam::OpFunc(tres.ref(), f1, dt2); \
677 tf1.clear(); \
678 return tres; \
679} \
680 \
681 \
682TEMPLATE \
683tmp<DimensionedField<ReturnType, GeoMesh>> operator Op \
684( \
685 const tmp<DimensionedField<Type1, GeoMesh>>& tf1, \
686 const Type2& s2 \
687) \
688{ \
689 return tf1 Op dimensioned<Type2>(s2); \
690}
691
692#define BINARY_TYPE_OPERATOR(ReturnType, Type1, Type2, Op, OpName, OpFunc) \
693 BINARY_TYPE_OPERATOR_SF(ReturnType, Type1, Type2, Op, OpName, OpFunc) \
694 BINARY_TYPE_OPERATOR_FS(ReturnType, Type1, Type2, Op, OpName, OpFunc)
695
696
697// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
698
699#define TERNARY_FUNCTION(ReturnType, Type1, Type2, Type3, Func) \
700 \
701TEMPLATE \
702void Func \
703( \
704 DimensionedField<ReturnType, GeoMesh>& result, \
705 const DimensionedField<Type1, GeoMesh>& f1, \
706 const DimensionedField<Type2, GeoMesh>& f2, \
707 const DimensionedField<Type3, GeoMesh>& f3 \
708) \
709{ \
710 /* TBD: reset dimensions? */ \
711 Func(result.field(), f1.field(), f2.field(), f3.field()); \
712 result.oriented() = Func(f1.oriented(), f2.oriented()); \
713} \
714 \
715TEMPLATE \
716tmp<DimensionedField<ReturnType, GeoMesh>> Func \
717( \
718 const DimensionedField<Type1, GeoMesh>& f1, \
719 const DimensionedField<Type2, GeoMesh>& f2, \
720 const DimensionedField<Type3, GeoMesh>& f3 \
721) \
722{ \
723 auto tres = \
724 reuseTmpDimensionedField<ReturnType, Type1, GeoMesh>::New \
725 ( \
726 f1, \
727 #Func "(" + f1.name() + ',' + f2.name() + ',' + f3.name() + ')', \
728 Func(f1.dimensions(), f2.dimensions()) \
729 ); \
730 \
731 Func(tres.ref(), f1, f2, f3); \
732 return tres; \
733} \
734 \
735TEMPLATE \
736tmp<DimensionedField<ReturnType, GeoMesh>> Func \
737( \
738 const tmp<DimensionedField<Type1, GeoMesh>>& tf1, \
739 const DimensionedField<Type2, GeoMesh>& f2, \
740 const DimensionedField<Type3, GeoMesh>& f3 \
741) \
742{ \
743 const auto& f1 = tf1(); \
744 \
745 auto tres = \
746 reuseTmpDimensionedField<ReturnType, Type1, GeoMesh>::New \
747 ( \
748 tf1, \
749 #Func "(" + f1.name() + ',' + f2.name() + ',' + f3.name() + ')', \
750 Func(f1.dimensions(), f2.dimensions()) \
751 ); \
752 \
753 Func(tres.ref(), f1, f2, f3); \
754 tf1.clear(); \
755 return tres; \
756} \
757 \
758TEMPLATE \
759tmp<DimensionedField<ReturnType, GeoMesh>> Func \
760( \
761 const DimensionedField<Type1, GeoMesh>& f1, \
762 const tmp<DimensionedField<Type2, GeoMesh>>& tf2, \
763 const DimensionedField<Type3, GeoMesh>& f3 \
764) \
765{ \
766 const auto& f2 = tf2(); \
767 \
768 auto tres = \
769 reuseTmpDimensionedField<ReturnType, Type2, GeoMesh>::New \
770 ( \
771 tf2, \
772 #Func "(" + f1.name() +','+ f2.name() +','+ f3.name() +')', \
773 Func(f1.dimensions(), f2.dimensions()) \
774 ); \
775 \
776 Func(tres.ref(), f1, f2, f3); \
777 tf2.clear(); \
778 return tres; \
779} \
780 \
781TEMPLATE \
782tmp<DimensionedField<ReturnType, GeoMesh>> Func \
783( \
784 const DimensionedField<Type1, GeoMesh>& f1, \
785 const DimensionedField<Type2, GeoMesh>& f2, \
786 const tmp<DimensionedField<Type3, GeoMesh>>& tf3 \
787) \
788{ \
789 const auto& f3 = tf3(); \
790 \
791 auto tres = \
792 reuseTmpDimensionedField<ReturnType, Type3, GeoMesh>::New \
793 ( \
794 tf3, \
795 #Func "(" + f1.name() +','+ f2.name() +','+ f3.name() +')', \
796 Func(f1.dimensions(), f2.dimensions()) \
797 ); \
798 \
799 Func(tres.ref(), f1, f2, f3); \
800 tf3.clear(); \
801 return tres; \
802} \
803 \
804 \
805TEMPLATE \
806tmp<DimensionedField<ReturnType, GeoMesh>> Func \
807( \
808 const tmp<DimensionedField<Type1, GeoMesh>>& tf1, \
809 const tmp<DimensionedField<Type2, GeoMesh>>& tf2, \
810 const DimensionedField<Type3, GeoMesh>& f3 \
811) \
812{ \
813 const auto& f1 = tf1(); \
814 const auto& f2 = tf2(); \
815 \
816 auto tres = \
817 reuseTmpTmpDimensionedField \
818 <ReturnType, Type1, Type1, Type2, GeoMesh>::New \
819 ( \
820 tf1, \
821 tf2, \
822 #Func "(" + f1.name() +','+ f2.name() +','+ f3.name() +')', \
823 Func(f1.dimensions(), f2.dimensions()) \
824 ); \
825 \
826 Func(tres.ref(), f1, f2, f3); \
827 tf1.clear(); \
828 tf2.clear(); \
829 return tres; \
830} \
831 \
832TEMPLATE \
833tmp<DimensionedField<ReturnType, GeoMesh>> Func \
834( \
835 const tmp<DimensionedField<Type1, GeoMesh>>& tf1, \
836 const DimensionedField<Type2, GeoMesh>& f2, \
837 const tmp<DimensionedField<Type3, GeoMesh>>& tf3 \
838) \
839{ \
840 const auto& f1 = tf1(); \
841 const auto& f3 = tf3(); \
842 \
843 auto tres = \
844 reuseTmpTmpDimensionedField \
845 <ReturnType, Type1, Type1, Type3, GeoMesh>::New \
846 ( \
847 tf1, \
848 tf3, \
849 #Func "(" + f1.name() +','+ f2.name() +','+ f3.name() +')', \
850 Func(f1.dimensions(), f2.dimensions()) \
851 ); \
852 \
853 Func(tres.ref(), f1, f2, f3); \
854 tf1.clear(); \
855 tf3.clear(); \
856 return tres; \
857} \
858 \
859TEMPLATE \
860tmp<DimensionedField<ReturnType, GeoMesh>> Func \
861( \
862 const DimensionedField<Type1, GeoMesh>& f1, \
863 const tmp<DimensionedField<Type2, GeoMesh>>& tf2, \
864 const tmp<DimensionedField<Type3, GeoMesh>>& tf3 \
865) \
866{ \
867 const auto& f2 = tf2(); \
868 const auto& f3 = tf3(); \
869 \
870 auto tres = \
871 reuseTmpTmpDimensionedField \
872 <ReturnType, Type2, Type2, Type3, GeoMesh>::New \
873 ( \
874 tf2, \
875 tf3, \
876 #Func "(" + f1.name() +','+ f2.name() +','+ f3.name() +')', \
877 Func(f1.dimensions(), f2.dimensions()) \
878 ); \
879 \
880 Func(tres.ref(), f1, f2, f3); \
881 tf2.clear(); \
882 tf3.clear(); \
883 return tres; \
884} \
885 \
886TEMPLATE \
887tmp<DimensionedField<ReturnType, GeoMesh>> Func \
888( \
889 const tmp<DimensionedField<Type1, GeoMesh>>& tf1, \
890 const tmp<DimensionedField<Type2, GeoMesh>>& tf2, \
891 const tmp<DimensionedField<Type3, GeoMesh>>& tf3 \
892) \
893{ \
894 const auto& f1 = tf1(); \
895 const auto& f2 = tf2(); \
896 const auto& f3 = tf3(); \
897 \
898 /* TBD: check all three types? */ \
899 auto tres = \
900 reuseTmpTmpDimensionedField \
901 <ReturnType, Type1, Type1, Type2, GeoMesh>::New \
902 ( \
903 tf1, \
904 tf2, \
905 #Func "(" + f1.name() +','+ f2.name() +','+ f3.name() +')', \
906 Func(f1.dimensions(), f2.dimensions()) \
907 ); \
908 \
909 Func(tres.ref(), f1, f2, f3); \
910 tf1.clear(); \
911 tf2.clear(); \
912 tf3.clear(); \
913 return tres; \
914} \
915
916
917#define TERNARY_TYPE_FUNCTION_FFS(ReturnType, Type1, Type2, Type3, Func) \
918 \
919TEMPLATE \
920void Func \
921( \
922 DimensionedField<ReturnType, GeoMesh>& result, \
923 const DimensionedField<Type1, GeoMesh>& f1, \
924 const DimensionedField<Type2, GeoMesh>& f2, \
925 const dimensioned<Type3>& dt3 \
926) \
927{ \
928 /* TBD: reset dimensions? */ \
929 Func(result.field(), f1.field(), f2.field(), dt3.value()); \
930 result.oriented() = Func(f1.oriented(), f2.oriented()); \
931} \
932 \
933TEMPLATE \
934tmp<DimensionedField<ReturnType, GeoMesh>> Func \
935( \
936 const DimensionedField<Type1, GeoMesh>& f1, \
937 const DimensionedField<Type2, GeoMesh>& f2, \
938 const dimensioned<Type3>& dt3 \
939) \
940{ \
941 auto tres = \
942 reuseTmpDimensionedField<ReturnType, Type1, GeoMesh>::New \
943 ( \
944 f1, \
945 #Func "(" + f1.name() + ',' + f2.name() + ',' + dt3.name() + ')', \
946 Func(f1.dimensions(), f2.dimensions()) \
947 ); \
948 \
949 Func(tres.ref(), f1, f2, dt3); \
950 return tres; \
951} \
952 \
953TEMPLATE \
954tmp<DimensionedField<ReturnType, GeoMesh>> Func \
955( \
956 const DimensionedField<Type1, GeoMesh>& f1, \
957 const DimensionedField<Type2, GeoMesh>& f2, \
958 const Type3& s3 \
959) \
960{ \
961 return Func(f1, f2, dimensioned<Type3>(s3)); \
962} \
963 \
964TEMPLATE \
965tmp<DimensionedField<ReturnType, GeoMesh>> Func \
966( \
967 const tmp<DimensionedField<Type1, GeoMesh>>& tf1, \
968 const DimensionedField<Type2, GeoMesh>& f2, \
969 const dimensioned<Type3>& dt3 \
970) \
971{ \
972 const auto& f1 = tf1(); \
973 \
974 auto tres = \
975 reuseTmpDimensionedField<ReturnType, Type1, GeoMesh>::New \
976 ( \
977 tf1, \
978 #Func "(" + f1.name() + ',' + f2.name() + ',' + dt3.name() + ')', \
979 Func(f1.dimensions(), f2.dimensions()) \
980 ); \
981 \
982 Func(tres.ref(), f1, f2, dt3); \
983 tf1.clear(); \
984 return tres; \
985} \
986 \
987TEMPLATE \
988tmp<DimensionedField<ReturnType, GeoMesh>> Func \
989( \
990 const tmp<DimensionedField<Type1, GeoMesh>>& tf1, \
991 const DimensionedField<Type2, GeoMesh>& f2, \
992 const Type3& s3 \
993) \
994{ \
995 return Func(tf1, f2, dimensioned<Type3>(s3)); \
996} \
997 \
998TEMPLATE \
999tmp<DimensionedField<ReturnType, GeoMesh>> Func \
1000( \
1001 const DimensionedField<Type1, GeoMesh>& f1, \
1002 const tmp<DimensionedField<Type2, GeoMesh>>& tf2, \
1003 const dimensioned<Type3>& dt3 \
1004) \
1005{ \
1006 const auto& f2 = tf2(); \
1007 \
1008 auto tres = \
1009 reuseTmpDimensionedField<ReturnType, Type2, GeoMesh>::New \
1010 ( \
1011 tf2, \
1012 #Func "(" + f1.name() + ',' + f2.name() + ',' + dt3.name() + ')', \
1013 Func(f1.dimensions(), f2.dimensions()) \
1014 ); \
1015 \
1016 Func(tres.ref(), f1, f2, dt3); \
1017 tf2.clear(); \
1018 return tres; \
1019} \
1020 \
1021TEMPLATE \
1022tmp<DimensionedField<ReturnType, GeoMesh>> Func \
1023( \
1024 const DimensionedField<Type1, GeoMesh>& f1, \
1025 const tmp<DimensionedField<Type2, GeoMesh>>& tf2, \
1026 const Type3& s3 \
1027) \
1028{ \
1029 return Func(f1, tf2, dimensioned<Type3>(s3)); \
1030} \
1031 \
1032TEMPLATE \
1033tmp<DimensionedField<ReturnType, GeoMesh>> Func \
1034( \
1035 const tmp<DimensionedField<Type1, GeoMesh>>& tf1, \
1036 const tmp<DimensionedField<Type2, GeoMesh>>& tf2, \
1037 const dimensioned<Type3>& dt3 \
1038) \
1039{ \
1040 const auto& f1 = tf1(); \
1041 const auto& f2 = tf2(); \
1042 \
1043 auto tres = \
1044 reuseTmpTmpDimensionedField \
1045 <ReturnType, Type1, Type1, Type2, GeoMesh>::New \
1046 ( \
1047 tf1, \
1048 tf2, \
1049 #Func "(" + f1.name() + ',' + f2.name() + ',' + dt3.name() + ')', \
1050 Func(f1.dimensions(), f2.dimensions()) \
1051 ); \
1052 \
1053 Func(tres.ref(), f1, f2, dt3); \
1054 tf1.clear(); \
1055 tf2.clear(); \
1056 return tres; \
1057} \
1058 \
1059TEMPLATE \
1060tmp<DimensionedField<ReturnType, GeoMesh>> Func \
1061( \
1062 const tmp<DimensionedField<Type1, GeoMesh>>& tf1, \
1063 const tmp<DimensionedField<Type2, GeoMesh>>& tf2, \
1064 const Type3& s3 \
1065) \
1066{ \
1067 return Func(tf1, tf2, dimensioned<Type3>(s3)); \
1068}
1069
1070
1071// ************************************************************************* //