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 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 \
36tmp<DimensionedField<ReturnType, GeoMesh>> Func \
37( \
38 const DimensionedField<Type1, GeoMesh>& df1 \
39) \
40{ \
41 auto tres = \
42 tmp<DimensionedField<ReturnType, GeoMesh>>::New \
43 ( \
44 IOobject \
45 ( \
46 #Func "(" + df1.name() + ')', \
47 df1.instance(), \
48 df1.db() \
49 ), \
50 df1.mesh(), \
51 Dfunc(df1.dimensions()) \
52 ); \
53 \
54 Func(tres.ref().field(), df1.field()); \
55 tres.ref().oriented() = Dfunc(df1.oriented()); \
56 \
57 return tres; \
58} \
59 \
60 \
61TEMPLATE \
62tmp<DimensionedField<ReturnType, GeoMesh>> Func \
63( \
64 const tmp<DimensionedField<Type1, GeoMesh>>& tdf1 \
65) \
66{ \
67 const DimensionedField<Type1, GeoMesh>& df1 = tdf1(); \
68 \
69 auto tres = \
70 reuseTmpDimensionedField<ReturnType, Type1, GeoMesh>::New \
71 ( \
72 tdf1, \
73 #Func "(" + df1.name() + ')', \
74 Dfunc(df1.dimensions()) \
75 ); \
76 \
77 Func(tres.ref().field(), df1.field()); \
78 tres.ref().oriented() = Dfunc(df1.oriented()); \
79 \
80 tdf1.clear(); \
81 return tres; \
82}
83
84
85// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
86
87#define UNARY_OPERATOR(ReturnType, Type1, Op, OpFunc, Dfunc) \
88 \
89TEMPLATE \
90tmp<DimensionedField<ReturnType, GeoMesh>> operator Op \
91( \
92 const DimensionedField<Type1, GeoMesh>& df1 \
93) \
94{ \
95 auto tres = \
96 tmp<DimensionedField<ReturnType, GeoMesh>>::New \
97 ( \
98 IOobject \
99 ( \
100 #Op + df1.name(), \
101 df1.instance(), \
102 df1.db() \
103 ), \
104 df1.mesh(), \
105 Dfunc(df1.dimensions()) \
106 ); \
107 \
108 Foam::OpFunc(tres.ref().field(), df1.field()); \
109 tres.ref().oriented() = Dfunc(df1.oriented()); \
110 \
111 return tres; \
112} \
113 \
114 \
115TEMPLATE \
116tmp<DimensionedField<ReturnType, GeoMesh>> operator Op \
117( \
118 const tmp<DimensionedField<Type1, GeoMesh>>& tdf1 \
119) \
120{ \
121 const DimensionedField<Type1, GeoMesh>& df1 = tdf1(); \
122 \
123 auto tres = \
124 reuseTmpDimensionedField<ReturnType, Type1, GeoMesh>::New \
125 ( \
126 tdf1, \
127 #Op + df1.name(), \
128 Dfunc(df1.dimensions()) \
129 ); \
130 \
131 Foam::OpFunc(tres.ref().field(), df1.field()); \
132 tres.ref().oriented() = Dfunc(df1.oriented()); \
133 \
134 tdf1.clear(); \
135 return tres; \
136}
137
138
139// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
140
141#define BINARY_FUNCTION(ReturnType, Type1, Type2, Func) \
142 \
143TEMPLATE \
144tmp<DimensionedField<ReturnType, GeoMesh>> Func \
145( \
146 const DimensionedField<Type1, GeoMesh>& df1, \
147 const DimensionedField<Type2, GeoMesh>& df2 \
148) \
149{ \
150 auto tres = \
151 tmp<DimensionedField<ReturnType, GeoMesh>>::New \
152 ( \
153 IOobject \
154 ( \
155 #Func "(" + df1.name() + ',' + df2.name() + ')', \
156 df1.instance(), \
157 df1.db() \
158 ), \
159 df1.mesh(), \
160 Func(df1.dimensions(), df2.dimensions()) \
161 ); \
162 \
163 Func(tres.ref().field(), df1.field(), df2.field()); \
164 tres.ref().oriented() = Func(df1.oriented(), df2.oriented()); \
165 \
166 return tres; \
167} \
168 \
169 \
170TEMPLATE \
171tmp<DimensionedField<ReturnType, GeoMesh>> Func \
172( \
173 const DimensionedField<Type1, GeoMesh>& df1, \
174 const tmp<DimensionedField<Type2, GeoMesh>>& tdf2 \
175) \
176{ \
177 const DimensionedField<Type2, GeoMesh>& df2 = tdf2(); \
178 \
179 auto tres = \
180 reuseTmpDimensionedField<ReturnType, Type2, GeoMesh>::New \
181 ( \
182 tdf2, \
183 #Func "(" + df1.name() + ',' + df2.name() + ')', \
184 Func(df1.dimensions(), df2.dimensions()) \
185 ); \
186 \
187 Func(tres.ref().field(), df1.field(), df2.field()); \
188 tres.ref().oriented() = Func(df1.oriented(), df2.oriented()); \
189 \
190 tdf2.clear(); \
191 return tres; \
192} \
193 \
194 \
195TEMPLATE \
196tmp<DimensionedField<ReturnType, GeoMesh>> Func \
197( \
198 const tmp<DimensionedField<Type1, GeoMesh>>& tdf1, \
199 const DimensionedField<Type2, GeoMesh>& df2 \
200) \
201{ \
202 const DimensionedField<Type1, GeoMesh>& df1 = tdf1(); \
203 \
204 tmp<DimensionedField<ReturnType, GeoMesh>> tres \
205 ( \
206 reuseTmpDimensionedField<ReturnType, Type1, GeoMesh>::New \
207 ( \
208 tdf1, \
209 #Func "(" + df1.name() + ',' + df2.name() + ')', \
210 Func(df1.dimensions(), df2.dimensions()) \
211 ) \
212 ); \
213 \
214 Func(tres.ref().field(), df1.field(), df2.field()); \
215 tres.ref().oriented() = Func(df1.oriented(), df2.oriented()); \
216 \
217 tdf1.clear(); \
218 return tres; \
219} \
220 \
221 \
222TEMPLATE \
223tmp<DimensionedField<ReturnType, GeoMesh>> Func \
224( \
225 const tmp<DimensionedField<Type1, GeoMesh>>& tdf1, \
226 const tmp<DimensionedField<Type2, GeoMesh>>& tdf2 \
227) \
228{ \
229 const DimensionedField<Type1, GeoMesh>& df1 = tdf1(); \
230 const DimensionedField<Type2, GeoMesh>& df2 = tdf2(); \
231 \
232 auto tres = \
233 reuseTmpTmpDimensionedField \
234 <ReturnType, Type1, Type1, Type2, GeoMesh>::New \
235 ( \
236 tdf1, \
237 tdf2, \
238 #Func "(" + df1.name() + ',' + df2.name() + ')', \
239 Func(df1.dimensions(), df2.dimensions()) \
240 ); \
241 \
242 Func(tres.ref().field(), df1.field(), df2.field()); \
243 tres.ref().oriented() = Func(df1.oriented(), df2.oriented()); \
244 \
245 tdf1.clear(); \
246 tdf2.clear(); \
247 return tres; \
248}
249
250
251// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
252
253#define BINARY_TYPE_FUNCTION_SF(ReturnType, Type1, Type2, Func) \
254 \
255TEMPLATE \
256tmp<DimensionedField<ReturnType, GeoMesh>> Func \
257( \
258 const dimensioned<Type1>& dt1, \
259 const DimensionedField<Type2, GeoMesh>& df2 \
260) \
261{ \
262 auto tres = \
263 tmp<DimensionedField<ReturnType, GeoMesh>>::New \
264 ( \
265 IOobject \
266 ( \
267 #Func "(" + dt1.name() + ',' + df2.name() + ')', \
268 df2.instance(), \
269 df2.db() \
270 ), \
271 df2.mesh(), \
272 Func(dt1.dimensions(), df2.dimensions()) \
273 ); \
274 \
275 Func(tres.ref().field(), dt1.value(), df2.field()); \
276 tres.ref().oriented() = df2.oriented(); \
277 \
278 return tres; \
279} \
280 \
281 \
282TEMPLATE \
283tmp<DimensionedField<ReturnType, GeoMesh>> Func \
284( \
285 const Type1& t1, \
286 const DimensionedField<Type2, GeoMesh>& df2 \
287) \
288{ \
289 return Func(dimensioned<Type1>(t1), df2); \
290} \
291 \
292 \
293TEMPLATE \
294tmp<DimensionedField<ReturnType, GeoMesh>> Func \
295( \
296 const dimensioned<Type1>& dt1, \
297 const tmp<DimensionedField<Type2, GeoMesh>>& tdf2 \
298) \
299{ \
300 const DimensionedField<Type2, GeoMesh>& df2 = tdf2(); \
301 \
302 auto tres = \
303 reuseTmpDimensionedField<ReturnType, Type2, GeoMesh>::New \
304 ( \
305 tdf2, \
306 #Func "(" + dt1.name() + ',' + df2.name() + ')', \
307 Func(dt1.dimensions(), df2.dimensions()) \
308 ); \
309 \
310 Func(tres.ref().field(), dt1.value(), df2.field()); \
311 tres.ref().oriented() = df2.oriented(); \
312 \
313 tdf2.clear(); \
314 return tres; \
315} \
316 \
317 \
318TEMPLATE \
319tmp<DimensionedField<ReturnType, GeoMesh>> Func \
320( \
321 const Type1& t1, \
322 const tmp<DimensionedField<Type2, GeoMesh>>& tdf2 \
323) \
324{ \
325 return Func(dimensioned<Type2>(t1), tdf2); \
326}
327
328
329#define BINARY_TYPE_FUNCTION_FS(ReturnType, Type1, Type2, Func) \
330 \
331TEMPLATE \
332tmp<DimensionedField<ReturnType, GeoMesh>> Func \
333( \
334 const DimensionedField<Type1, GeoMesh>& df1, \
335 const dimensioned<Type2>& dt2 \
336) \
337{ \
338 auto tres = \
339 tmp<DimensionedField<ReturnType, GeoMesh>>::New \
340 ( \
341 IOobject \
342 ( \
343 #Func "(" + df1.name() + ',' + dt2.name() + ')', \
344 df1.instance(), \
345 df1.db() \
346 ), \
347 df1.mesh(), \
348 Func(df1.dimensions(), dt2.dimensions()) \
349 ); \
350 \
351 Func(tres.ref().field(), df1.field(), dt2.value()); \
352 tres.ref().oriented() = df1.oriented(); \
353 \
354 return tres; \
355} \
356 \
357 \
358TEMPLATE \
359tmp<DimensionedField<ReturnType, GeoMesh>> Func \
360( \
361 const DimensionedField<Type1, GeoMesh>& df1, \
362 const Type2& t2 \
363) \
364{ \
365 return Func(df1, dimensioned<Type2>(t2)); \
366} \
367 \
368 \
369TEMPLATE \
370tmp<DimensionedField<ReturnType, GeoMesh>> Func \
371( \
372 const tmp<DimensionedField<Type1, GeoMesh>>& tdf1, \
373 const dimensioned<Type2>& dt2 \
374) \
375{ \
376 const DimensionedField<Type1, GeoMesh>& df1 = tdf1(); \
377 \
378 auto tres = \
379 reuseTmpDimensionedField<ReturnType, Type1, GeoMesh>::New \
380 ( \
381 tdf1, \
382 #Func "(" + df1.name() + ',' + dt2.name() + ')', \
383 Func(df1.dimensions(), dt2.dimensions()) \
384 ); \
385 \
386 Func(tres.ref().field(), df1.field(), dt2.value()); \
387 tres.ref().oriented() = df1.oriented(); \
388 \
389 tdf1.clear(); \
390 return tres; \
391} \
392 \
393 \
394TEMPLATE \
395tmp<DimensionedField<ReturnType, GeoMesh>> Func \
396( \
397 const tmp<DimensionedField<Type1, GeoMesh>>& tdf1, \
398 const Type2& t2 \
399) \
400{ \
401 return Func(tdf1, dimensioned<Type2>(t2)); \
402}
403
404
405#define BINARY_TYPE_FUNCTION(ReturnType, Type1, Type2, Func) \
406 BINARY_TYPE_FUNCTION_SF(ReturnType, Type1, Type2, Func) \
407 BINARY_TYPE_FUNCTION_FS(ReturnType, Type1, Type2, Func)
408
409
410// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
411
412#define BINARY_OPERATOR(ReturnType, Type1, Type2, Op, OpName, OpFunc) \
413 \
414TEMPLATE \
415tmp<DimensionedField<ReturnType, GeoMesh>> operator Op \
416( \
417 const DimensionedField<Type1, GeoMesh>& df1, \
418 const DimensionedField<Type2, GeoMesh>& df2 \
419) \
420{ \
421 auto tres = \
422 tmp<DimensionedField<ReturnType, GeoMesh>>::New \
423 ( \
424 IOobject \
425 ( \
426 '(' + df1.name() + OpName + df2.name() + ')', \
427 df1.instance(), \
428 df1.db() \
429 ), \
430 df1.mesh(), \
431 df1.dimensions() Op df2.dimensions() \
432 ); \
433 \
434 Foam::OpFunc(tres.ref().field(), df1.field(), df2.field()); \
435 tres.ref().oriented() = df1.oriented() Op df2.oriented(); \
436 \
437 return tres; \
438} \
439 \
440 \
441TEMPLATE \
442tmp<DimensionedField<ReturnType, GeoMesh>> operator Op \
443( \
444 const DimensionedField<Type1, GeoMesh>& df1, \
445 const tmp<DimensionedField<Type2, GeoMesh>>& tdf2 \
446) \
447{ \
448 const DimensionedField<Type2, GeoMesh>& df2 = tdf2(); \
449 \
450 auto tres = \
451 reuseTmpDimensionedField<ReturnType, Type2, GeoMesh>::New \
452 ( \
453 tdf2, \
454 '(' + df1.name() + OpName + df2.name() + ')', \
455 df1.dimensions() Op df2.dimensions() \
456 ); \
457 \
458 Foam::OpFunc(tres.ref().field(), df1.field(), df2.field()); \
459 tres.ref().oriented() = df1.oriented() Op df2.oriented(); \
460 \
461 tdf2.clear(); \
462 return tres; \
463} \
464 \
465 \
466TEMPLATE \
467tmp<DimensionedField<ReturnType, GeoMesh>> operator Op \
468( \
469 const tmp<DimensionedField<Type1, GeoMesh>>& tdf1, \
470 const DimensionedField<Type2, GeoMesh>& df2 \
471) \
472{ \
473 const DimensionedField<Type1, GeoMesh>& df1 = tdf1(); \
474 \
475 auto tres = \
476 reuseTmpDimensionedField<ReturnType, Type1, GeoMesh>::New \
477 ( \
478 tdf1, \
479 '(' + df1.name() + OpName + df2.name() + ')', \
480 df1.dimensions() Op df2.dimensions() \
481 ); \
482 \
483 Foam::OpFunc(tres.ref().field(), df1.field(), df2.field()); \
484 tres.ref().oriented() = df1.oriented() Op df2.oriented(); \
485 \
486 tdf1.clear(); \
487 return tres; \
488} \
489 \
490 \
491TEMPLATE \
492tmp<DimensionedField<ReturnType, GeoMesh>> operator Op \
493( \
494 const tmp<DimensionedField<Type1, GeoMesh>>& tdf1, \
495 const tmp<DimensionedField<Type2, GeoMesh>>& tdf2 \
496) \
497{ \
498 const DimensionedField<Type1, GeoMesh>& df1 = tdf1(); \
499 const DimensionedField<Type2, GeoMesh>& df2 = tdf2(); \
500 \
501 auto tres = \
502 reuseTmpTmpDimensionedField \
503 <ReturnType, Type1, Type1, Type2, GeoMesh>::New \
504 ( \
505 tdf1, \
506 tdf2, \
507 '(' + df1.name() + OpName + df2.name() + ')', \
508 df1.dimensions() Op df2.dimensions() \
509 ); \
510 \
511 Foam::OpFunc(tres.ref().field(), df1.field(), df2.field()); \
512 tres.ref().oriented() = df1.oriented() Op df2.oriented(); \
513 \
514 tdf1.clear(); \
515 tdf2.clear(); \
516 return tres; \
517}
518
519
520// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
521
522#define BINARY_TYPE_OPERATOR_SF(ReturnType, Type1, Type2, Op, OpName, OpFunc) \
523 \
524TEMPLATE \
525tmp<DimensionedField<ReturnType, GeoMesh>> operator Op \
526( \
527 const dimensioned<Type1>& dt1, \
528 const DimensionedField<Type2, GeoMesh>& df2 \
529) \
530{ \
531 auto tres = \
532 tmp<DimensionedField<ReturnType, GeoMesh>>::New \
533 ( \
534 IOobject \
535 ( \
536 '(' + dt1.name() + OpName + df2.name() + ')', \
537 df2.instance(), \
538 df2.db() \
539 ), \
540 df2.mesh(), \
541 dt1.dimensions() Op df2.dimensions() \
542 ); \
543 \
544 tres.ref().oriented() = df2.oriented(); \
545 \
546 Foam::OpFunc(tres.ref().field(), dt1.value(), df2.field()); \
547 \
548 return tres; \
549} \
550 \
551 \
552TEMPLATE \
553tmp<DimensionedField<ReturnType, GeoMesh>> operator Op \
554( \
555 const Type1& t1, \
556 const DimensionedField<Type2, GeoMesh>& df2 \
557) \
558{ \
559 return dimensioned<Type1>(t1) Op df2; \
560} \
561 \
562 \
563TEMPLATE \
564tmp<DimensionedField<ReturnType, GeoMesh>> operator Op \
565( \
566 const dimensioned<Type1>& dt1, \
567 const tmp<DimensionedField<Type2, GeoMesh>>& tdf2 \
568) \
569{ \
570 const DimensionedField<Type2, GeoMesh>& df2 = tdf2(); \
571 \
572 auto tres = \
573 reuseTmpDimensionedField<ReturnType, Type2, GeoMesh>::New \
574 ( \
575 tdf2, \
576 '(' + dt1.name() + OpName + df2.name() + ')', \
577 dt1.dimensions() Op df2.dimensions() \
578 ); \
579 \
580 Foam::OpFunc(tres.ref().field(), dt1.value(), tdf2().field()); \
581 tres.ref().oriented() = df2.oriented(); \
582 \
583 tdf2.clear(); \
584 return tres; \
585} \
586 \
587 \
588TEMPLATE \
589tmp<DimensionedField<ReturnType, GeoMesh>> operator Op \
590( \
591 const Type1& t1, \
592 const tmp<DimensionedField<Type2, GeoMesh>>& tdf2 \
593) \
594{ \
595 return dimensioned<Type1>(t1) Op tdf2; \
596}
597
598
599#define BINARY_TYPE_OPERATOR_FS(ReturnType, Type1, Type2, Op, OpName, OpFunc) \
600 \
601TEMPLATE \
602tmp<DimensionedField<ReturnType, GeoMesh>> operator Op \
603( \
604 const DimensionedField<Type1, GeoMesh>& df1, \
605 const dimensioned<Type2>& dt2 \
606) \
607{ \
608 auto tres = \
609 tmp<DimensionedField<ReturnType, GeoMesh>>::New \
610 ( \
611 IOobject \
612 ( \
613 '(' + df1.name() + OpName + dt2.name() + ')', \
614 df1.instance(), \
615 df1.db() \
616 ), \
617 df1.mesh(), \
618 df1.dimensions() Op dt2.dimensions() \
619 ); \
620 \
621 Foam::OpFunc(tres.ref().field(), df1.field(), dt2.value()); \
622 tres.ref().oriented() = df1.oriented(); \
623 \
624 return tres; \
625} \
626 \
627 \
628TEMPLATE \
629tmp<DimensionedField<ReturnType, GeoMesh>> operator Op \
630( \
631 const DimensionedField<Type1, GeoMesh>& df1, \
632 const Type2& t2 \
633) \
634{ \
635 return df1 Op dimensioned<Type2>(t2); \
636} \
637 \
638 \
639TEMPLATE \
640tmp<DimensionedField<ReturnType, GeoMesh>> operator Op \
641( \
642 const tmp<DimensionedField<Type1, GeoMesh>>& tdf1, \
643 const dimensioned<Type2>& dt2 \
644) \
645{ \
646 const DimensionedField<Type1, GeoMesh>& df1 = tdf1(); \
647 \
648 auto tres = \
649 reuseTmpDimensionedField<ReturnType, Type1, GeoMesh>::New \
650 ( \
651 tdf1, \
652 '(' + df1.name() + OpName + dt2.name() + ')', \
653 df1.dimensions() Op dt2.dimensions() \
654 ); \
655 \
656 Foam::OpFunc(tres.ref().field(), tdf1().field(), dt2.value()); \
657 tres.ref().oriented() = df1.oriented(); \
658 \
659 tdf1.clear(); \
660 return tres; \
661} \
662 \
663 \
664TEMPLATE \
665tmp<DimensionedField<ReturnType, GeoMesh>> operator Op \
666( \
667 const tmp<DimensionedField<Type1, GeoMesh>>& tdf1, \
668 const Type2& t2 \
669) \
670{ \
671 return tdf1 Op dimensioned<Type2>(t2); \
672}
673
674#define BINARY_TYPE_OPERATOR(ReturnType, Type1, Type2, Op, OpName, OpFunc) \
675 BINARY_TYPE_OPERATOR_SF(ReturnType, Type1, Type2, Op, OpName, OpFunc) \
676 BINARY_TYPE_OPERATOR_FS(ReturnType, Type1, Type2, Op, OpName, OpFunc)
677
678
679// ************************************************************************* //