GeometricFieldFunctionsM.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 "GeometricFieldReuseFunctions.H"
30
31// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
32
33namespace Foam
34{
35
36// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
37
38#define UNARY_FUNCTION(ReturnType, Type1, Func, Dfunc) \
39 \
40TEMPLATE \
41void Func \
42( \
43 GeometricField<ReturnType, PatchField, GeoMesh>& res, \
44 const GeometricField<Type1, PatchField, GeoMesh>& gf1 \
45) \
46{ \
47 Foam::Func(res.primitiveFieldRef(), gf1.primitiveField()); \
48 Foam::Func(res.boundaryFieldRef(), gf1.boundaryField()); \
49 res.oriented() = gf1.oriented(); \
50} \
51 \
52 \
53TEMPLATE \
54tmp<GeometricField<ReturnType, PatchField, GeoMesh>> Func \
55( \
56 const GeometricField<Type1, PatchField, GeoMesh>& gf1 \
57) \
58{ \
59 auto tres = \
60 tmp<GeometricField<ReturnType, PatchField, GeoMesh>>::New \
61 ( \
62 IOobject \
63 ( \
64 #Func "(" + gf1.name() + ')', \
65 gf1.instance(), \
66 gf1.db(), \
67 IOobject::NO_READ, \
68 IOobject::NO_WRITE \
69 ), \
70 gf1.mesh(), \
71 Dfunc(gf1.dimensions()) \
72 ); \
73 \
74 Foam::Func(tres.ref(), gf1); \
75 \
76 return tres; \
77} \
78 \
79 \
80TEMPLATE \
81tmp<GeometricField<ReturnType, PatchField, GeoMesh>> Func \
82( \
83 const tmp<GeometricField<Type1, PatchField, GeoMesh>>& tgf1 \
84) \
85{ \
86 const GeometricField<Type1, PatchField, GeoMesh>& gf1 = tgf1(); \
87 \
88 auto tres = \
89 reuseTmpGeometricField<ReturnType, Type1, PatchField, GeoMesh>::New \
90 ( \
91 tgf1, \
92 #Func "(" + gf1.name() + ')', \
93 Dfunc(gf1.dimensions()) \
94 ); \
95 \
96 Foam::Func(tres.ref(), gf1); \
97 \
98 tgf1.clear(); \
99 \
100 return tres; \
101}
102
103
104// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
105
106#define UNARY_OPERATOR(ReturnType, Type1, Op, OpFunc, Dfunc) \
107 \
108TEMPLATE \
109void OpFunc \
110( \
111 GeometricField<ReturnType, PatchField, GeoMesh>& res, \
112 const GeometricField<Type1, PatchField, GeoMesh>& gf1 \
113) \
114{ \
115 Foam::OpFunc(res.primitiveFieldRef(), gf1.primitiveField()); \
116 Foam::OpFunc(res.boundaryFieldRef(), gf1.boundaryField()); \
117 res.oriented() = gf1.oriented(); \
118} \
119 \
120TEMPLATE \
121tmp<GeometricField<ReturnType, PatchField, GeoMesh>> operator Op \
122( \
123 const GeometricField<Type1, PatchField, GeoMesh>& gf1 \
124) \
125{ \
126 auto tres = \
127 tmp<GeometricField<ReturnType, PatchField, GeoMesh>>::New \
128 ( \
129 IOobject \
130 ( \
131 #Op + gf1.name(), \
132 gf1.instance(), \
133 gf1.db(), \
134 IOobject::NO_READ, \
135 IOobject::NO_WRITE \
136 ), \
137 gf1.mesh(), \
138 Dfunc(gf1.dimensions()) \
139 ); \
140 \
141 Foam::OpFunc(tres.ref(), gf1); \
142 \
143 return tres; \
144} \
145 \
146 \
147TEMPLATE \
148tmp<GeometricField<ReturnType, PatchField, GeoMesh>> operator Op \
149( \
150 const tmp<GeometricField<Type1, PatchField, GeoMesh>>& tgf1 \
151) \
152{ \
153 const GeometricField<Type1, PatchField, GeoMesh>& gf1 = tgf1(); \
154 \
155 auto tres = \
156 reuseTmpGeometricField<ReturnType, Type1, PatchField, GeoMesh>::New \
157 ( \
158 tgf1, \
159 #Op + gf1.name(), \
160 Dfunc(gf1.dimensions()) \
161 ); \
162 \
163 Foam::OpFunc(tres.ref(), gf1); \
164 \
165 tgf1.clear(); \
166 \
167 return tres; \
168}
169
170
171// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
172
173#define BINARY_FUNCTION(ReturnType, Type1, Type2, Func) \
174 \
175TEMPLATE \
176void Func \
177( \
178 GeometricField<ReturnType, PatchField, GeoMesh>& res, \
179 const GeometricField<Type1, PatchField, GeoMesh>& gf1, \
180 const GeometricField<Type2, PatchField, GeoMesh>& gf2 \
181) \
182{ \
183 Foam::Func \
184 ( \
185 res.primitiveFieldRef(), \
186 gf1.primitiveField(), \
187 gf2.primitiveField() \
188 ); \
189 Foam::Func \
190 ( \
191 res.boundaryFieldRef(), \
192 gf1.boundaryField(), \
193 gf2.boundaryField() \
194 ); \
195 res.oriented() = Func(gf1.oriented(), gf2.oriented()); \
196} \
197 \
198 \
199TEMPLATE \
200tmp<GeometricField<ReturnType, PatchField, GeoMesh>> Func \
201( \
202 const GeometricField<Type1, PatchField, GeoMesh>& gf1, \
203 const GeometricField<Type2, PatchField, GeoMesh>& gf2 \
204) \
205{ \
206 auto tres = \
207 tmp<GeometricField<ReturnType, PatchField, GeoMesh>>::New \
208 ( \
209 IOobject \
210 ( \
211 #Func "(" + gf1.name() + ',' + gf2.name() + ')', \
212 gf1.instance(), \
213 gf1.db(), \
214 IOobject::NO_READ, \
215 IOobject::NO_WRITE \
216 ), \
217 gf1.mesh(), \
218 Func(gf1.dimensions(), gf2.dimensions()) \
219 ); \
220 \
221 Foam::Func(tres.ref(), gf1, gf2); \
222 \
223 return tres; \
224} \
225 \
226 \
227TEMPLATE \
228tmp<GeometricField<ReturnType, PatchField, GeoMesh>> Func \
229( \
230 const GeometricField<Type1, PatchField, GeoMesh>& gf1, \
231 const tmp<GeometricField<Type2, PatchField, GeoMesh>>& tgf2 \
232) \
233{ \
234 const GeometricField<Type2, PatchField, GeoMesh>& gf2 = tgf2(); \
235 \
236 auto tres = \
237 reuseTmpGeometricField<ReturnType, Type2, PatchField, GeoMesh>::New \
238 ( \
239 tgf2, \
240 #Func "(" + gf1.name() + ',' + gf2.name() + ')', \
241 Func(gf1.dimensions(), gf2.dimensions()) \
242 ); \
243 \
244 Foam::Func(tres.ref(), gf1, gf2); \
245 \
246 tgf2.clear(); \
247 \
248 return tres; \
249} \
250 \
251 \
252TEMPLATE \
253tmp<GeometricField<ReturnType, PatchField, GeoMesh>> Func \
254( \
255 const tmp<GeometricField<Type1, PatchField, GeoMesh>>& tgf1, \
256 const GeometricField<Type2, PatchField, GeoMesh>& gf2 \
257) \
258{ \
259 const GeometricField<Type1, PatchField, GeoMesh>& gf1 = tgf1(); \
260 \
261 auto tres = \
262 reuseTmpGeometricField<ReturnType, Type1, PatchField, GeoMesh>::New \
263 ( \
264 tgf1, \
265 #Func "(" + gf1.name() + ',' + gf2.name() + ')', \
266 Func(gf1.dimensions(), gf2.dimensions()) \
267 ); \
268 \
269 Foam::Func(tres.ref(), gf1, gf2); \
270 \
271 tgf1.clear(); \
272 \
273 return tres; \
274} \
275 \
276 \
277TEMPLATE \
278tmp<GeometricField<ReturnType, PatchField, GeoMesh>> Func \
279( \
280 const tmp<GeometricField<Type1, PatchField, GeoMesh>>& tgf1, \
281 const tmp<GeometricField<Type2, PatchField, GeoMesh>>& tgf2 \
282) \
283{ \
284 const GeometricField<Type1, PatchField, GeoMesh>& gf1 = tgf1(); \
285 const GeometricField<Type2, PatchField, GeoMesh>& gf2 = tgf2(); \
286 \
287 auto tres = \
288 reuseTmpTmpGeometricField \
289 <ReturnType, Type1, Type1, Type2, PatchField, GeoMesh> \
290 ::New \
291 ( \
292 tgf1, \
293 tgf2, \
294 #Func "(" + gf1.name() + ',' + gf2.name() + ')', \
295 Func(gf1.dimensions(), gf2.dimensions()) \
296 ); \
297 \
298 Foam::Func(tres.ref(), gf1, gf2); \
299 \
300 tgf1.clear(); \
301 tgf2.clear(); \
302 \
303 return tres; \
304}
305
306
307// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
308
309#define BINARY_TYPE_FUNCTION_SF(ReturnType, Type1, Type2, Func) \
310 \
311TEMPLATE \
312void Func \
313( \
314 GeometricField<ReturnType, PatchField, GeoMesh>& res, \
315 const dimensioned<Type1>& dt1, \
316 const GeometricField<Type2, PatchField, GeoMesh>& gf2 \
317) \
318{ \
319 Foam::Func(res.primitiveFieldRef(), dt1.value(), gf2.primitiveField()); \
320 Foam::Func(res.boundaryFieldRef(), dt1.value(), gf2.boundaryField()); \
321 res.oriented() = gf2.oriented(); \
322} \
323 \
324 \
325TEMPLATE \
326tmp<GeometricField<ReturnType, PatchField, GeoMesh>> Func \
327( \
328 const dimensioned<Type1>& dt1, \
329 const GeometricField<Type2, PatchField, GeoMesh>& gf2 \
330) \
331{ \
332 auto tres = \
333 tmp<GeometricField<ReturnType, PatchField, GeoMesh>>::New \
334 ( \
335 IOobject \
336 ( \
337 #Func "(" + dt1.name() + ',' + gf2.name() + ')', \
338 gf2.instance(), \
339 gf2.db(), \
340 IOobject::NO_READ, \
341 IOobject::NO_WRITE \
342 ), \
343 gf2.mesh(), \
344 Func(dt1.dimensions(), gf2.dimensions()) \
345 ); \
346 \
347 Foam::Func(tres.ref(), dt1, gf2); \
348 \
349 return tres; \
350} \
351 \
352 \
353TEMPLATE \
354tmp<GeometricField<ReturnType, PatchField, GeoMesh>> Func \
355( \
356 const Type1& t1, \
357 const GeometricField<Type2, PatchField, GeoMesh>& gf2 \
358) \
359{ \
360 return Func(dimensioned<Type1>(t1), gf2); \
361} \
362 \
363 \
364TEMPLATE \
365tmp<GeometricField<ReturnType, PatchField, GeoMesh>> Func \
366( \
367 const dimensioned<Type1>& dt1, \
368 const tmp<GeometricField<Type2, PatchField, GeoMesh>>& tgf2 \
369) \
370{ \
371 const GeometricField<Type2, PatchField, GeoMesh>& gf2 = tgf2(); \
372 \
373 auto tres = \
374 reuseTmpGeometricField<ReturnType, Type2, PatchField, GeoMesh>::New \
375 ( \
376 tgf2, \
377 #Func "(" + dt1.name() + gf2.name() + ',' + ')', \
378 Func(dt1.dimensions(), gf2.dimensions()) \
379 ); \
380 \
381 Foam::Func(tres.ref(), dt1, gf2); \
382 \
383 tgf2.clear(); \
384 \
385 return tres; \
386} \
387 \
388 \
389TEMPLATE \
390tmp<GeometricField<ReturnType, PatchField, GeoMesh>> Func \
391( \
392 const Type1& t1, \
393 const tmp<GeometricField<Type2, PatchField, GeoMesh>>& tgf2 \
394) \
395{ \
396 return Func(dimensioned<Type1>(t1), tgf2); \
397}
398
399
400#define BINARY_TYPE_FUNCTION_FS(ReturnType, Type1, Type2, Func) \
401 \
402TEMPLATE \
403void Func \
404( \
405 GeometricField<ReturnType, PatchField, GeoMesh>& res, \
406 const GeometricField<Type1, PatchField, GeoMesh>& gf1, \
407 const dimensioned<Type2>& dt2 \
408) \
409{ \
410 Foam::Func(res.primitiveFieldRef(), gf1.primitiveField(), dt2.value()); \
411 Foam::Func(res.boundaryFieldRef(), gf1.boundaryField(), dt2.value()); \
412 res.oriented() = gf1.oriented(); \
413} \
414 \
415 \
416TEMPLATE \
417tmp<GeometricField<ReturnType, PatchField, GeoMesh>> Func \
418( \
419 const GeometricField<Type1, PatchField, GeoMesh>& gf1, \
420 const dimensioned<Type2>& dt2 \
421) \
422{ \
423 auto tres = \
424 tmp<GeometricField<ReturnType, PatchField, GeoMesh>>::New \
425 ( \
426 IOobject \
427 ( \
428 #Func "(" + gf1.name() + ',' + dt2.name() + ')', \
429 gf1.instance(), \
430 gf1.db(), \
431 IOobject::NO_READ, \
432 IOobject::NO_WRITE \
433 ), \
434 gf1.mesh(), \
435 Func(gf1.dimensions(), dt2.dimensions()) \
436 ); \
437 \
438 Foam::Func(tres.ref(), gf1, dt2); \
439 \
440 return tres; \
441} \
442 \
443 \
444TEMPLATE \
445tmp<GeometricField<ReturnType, PatchField, GeoMesh>> Func \
446( \
447 const GeometricField<Type1, PatchField, GeoMesh>& gf1, \
448 const Type2& t2 \
449) \
450{ \
451 return Func(gf1, dimensioned<Type2>(t2)); \
452} \
453 \
454 \
455TEMPLATE \
456tmp<GeometricField<ReturnType, PatchField, GeoMesh>> Func \
457( \
458 const tmp<GeometricField<Type1, PatchField, GeoMesh>>& tgf1, \
459 const dimensioned<Type2>& dt2 \
460) \
461{ \
462 const GeometricField<Type1, PatchField, GeoMesh>& gf1 = tgf1(); \
463 \
464 auto tres = \
465 reuseTmpGeometricField<ReturnType, Type1, PatchField, GeoMesh>::New \
466 ( \
467 tgf1, \
468 #Func "(" + gf1.name() + ',' + dt2.name() + ')', \
469 Func(gf1.dimensions(), dt2.dimensions()) \
470 ); \
471 \
472 Foam::Func(tres.ref(), gf1, dt2); \
473 \
474 tgf1.clear(); \
475 \
476 return tres; \
477} \
478 \
479 \
480TEMPLATE \
481tmp<GeometricField<ReturnType, PatchField, GeoMesh>> Func \
482( \
483 const tmp<GeometricField<Type1, PatchField, GeoMesh>>& tgf1, \
484 const Type2& t2 \
485) \
486{ \
487 return Func(tgf1, dimensioned<Type2>(t2)); \
488}
489
490
491#define BINARY_TYPE_FUNCTION(ReturnType, Type1, Type2, Func) \
492 BINARY_TYPE_FUNCTION_SF(ReturnType, Type1, Type2, Func) \
493 BINARY_TYPE_FUNCTION_FS(ReturnType, Type1, Type2, Func)
494
495
496// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
497
498#define BINARY_OPERATOR(ReturnType, Type1, Type2, Op, OpName, OpFunc) \
499 \
500TEMPLATE \
501void OpFunc \
502( \
503 GeometricField<ReturnType, PatchField, GeoMesh>& res, \
504 const GeometricField<Type1, PatchField, GeoMesh>& gf1, \
505 const GeometricField<Type2, PatchField, GeoMesh>& gf2 \
506) \
507{ \
508 Foam::OpFunc \
509 (res.primitiveFieldRef(), gf1.primitiveField(), gf2.primitiveField()); \
510 Foam::OpFunc \
511 (res.boundaryFieldRef(), gf1.boundaryField(), gf2.boundaryField()); \
512 res.oriented() = gf1.oriented() Op gf2.oriented(); \
513} \
514 \
515 \
516TEMPLATE \
517tmp<GeometricField<ReturnType, PatchField, GeoMesh>> operator Op \
518( \
519 const GeometricField<Type1, PatchField, GeoMesh>& gf1, \
520 const GeometricField<Type2, PatchField, GeoMesh>& gf2 \
521) \
522{ \
523 auto tres = \
524 tmp<GeometricField<ReturnType, PatchField, GeoMesh>>::New \
525 ( \
526 IOobject \
527 ( \
528 '(' + gf1.name() + OpName + gf2.name() + ')', \
529 gf1.instance(), \
530 gf1.db(), \
531 IOobject::NO_READ, \
532 IOobject::NO_WRITE \
533 ), \
534 gf1.mesh(), \
535 gf1.dimensions() Op gf2.dimensions() \
536 ); \
537 \
538 Foam::OpFunc(tres.ref(), gf1, gf2); \
539 \
540 return tres; \
541} \
542 \
543 \
544TEMPLATE \
545tmp<GeometricField<ReturnType, PatchField, GeoMesh>> operator Op \
546( \
547 const GeometricField<Type1, PatchField, GeoMesh>& gf1, \
548 const tmp<GeometricField<Type2, PatchField, GeoMesh>>& tgf2 \
549) \
550{ \
551 const GeometricField<Type2, PatchField, GeoMesh>& gf2 = tgf2(); \
552 \
553 auto tres = \
554 reuseTmpGeometricField<ReturnType, Type2, PatchField, GeoMesh>::New \
555 ( \
556 tgf2, \
557 '(' + gf1.name() + OpName + gf2.name() + ')', \
558 gf1.dimensions() Op gf2.dimensions() \
559 ); \
560 \
561 Foam::OpFunc(tres.ref(), gf1, gf2); \
562 \
563 tgf2.clear(); \
564 \
565 return tres; \
566} \
567 \
568 \
569TEMPLATE \
570tmp<GeometricField<ReturnType, PatchField, GeoMesh>> operator Op \
571( \
572 const tmp<GeometricField<Type1, PatchField, GeoMesh>>& tgf1, \
573 const GeometricField<Type2, PatchField, GeoMesh>& gf2 \
574) \
575{ \
576 const GeometricField<Type1, PatchField, GeoMesh>& gf1 = tgf1(); \
577 \
578 auto tres = \
579 reuseTmpGeometricField<ReturnType, Type1, PatchField, GeoMesh>::New \
580 ( \
581 tgf1, \
582 '(' + gf1.name() + OpName + gf2.name() + ')', \
583 gf1.dimensions() Op gf2.dimensions() \
584 ); \
585 \
586 Foam::OpFunc(tres.ref(), gf1, gf2); \
587 \
588 tgf1.clear(); \
589 \
590 return tres; \
591} \
592 \
593 \
594TEMPLATE \
595tmp<GeometricField<ReturnType, PatchField, GeoMesh>> operator Op \
596( \
597 const tmp<GeometricField<Type1, PatchField, GeoMesh>>& tgf1, \
598 const tmp<GeometricField<Type2, PatchField, GeoMesh>>& tgf2 \
599) \
600{ \
601 const GeometricField<Type1, PatchField, GeoMesh>& gf1 = tgf1(); \
602 const GeometricField<Type2, PatchField, GeoMesh>& gf2 = tgf2(); \
603 \
604 auto tres = \
605 reuseTmpTmpGeometricField \
606 <ReturnType, Type1, Type1, Type2, PatchField, GeoMesh>::New \
607 ( \
608 tgf1, \
609 tgf2, \
610 '(' + gf1.name() + OpName + gf2.name() + ')', \
611 gf1.dimensions() Op gf2.dimensions() \
612 ); \
613 \
614 Foam::OpFunc(tres.ref(), gf1, gf2); \
615 \
616 tgf1.clear(); \
617 tgf2.clear(); \
618 \
619 return tres; \
620}
621
622
623// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
624
625#define BINARY_TYPE_OPERATOR_SF(ReturnType, Type1, Type2, Op, OpName, OpFunc) \
626 \
627TEMPLATE \
628void OpFunc \
629( \
630 GeometricField<ReturnType, PatchField, GeoMesh>& res, \
631 const dimensioned<Type1>& dt1, \
632 const GeometricField<Type2, PatchField, GeoMesh>& gf2 \
633) \
634{ \
635 Foam::OpFunc(res.primitiveFieldRef(), dt1.value(), gf2.primitiveField()); \
636 Foam::OpFunc(res.boundaryFieldRef(), dt1.value(), gf2.boundaryField()); \
637 res.oriented() = gf2.oriented(); \
638 \
639} \
640 \
641TEMPLATE \
642tmp<GeometricField<ReturnType, PatchField, GeoMesh>> operator Op \
643( \
644 const dimensioned<Type1>& dt1, \
645 const GeometricField<Type2, PatchField, GeoMesh>& gf2 \
646) \
647{ \
648 auto tres = \
649 tmp<GeometricField<ReturnType, PatchField, GeoMesh>>::New \
650 ( \
651 IOobject \
652 ( \
653 '(' + dt1.name() + OpName + gf2.name() + ')', \
654 gf2.instance(), \
655 gf2.db(), \
656 IOobject::NO_READ, \
657 IOobject::NO_WRITE \
658 ), \
659 gf2.mesh(), \
660 dt1.dimensions() Op gf2.dimensions() \
661 ); \
662 \
663 Foam::OpFunc(tres.ref(), dt1, gf2); \
664 \
665 return tres; \
666} \
667 \
668 \
669TEMPLATE \
670tmp<GeometricField<ReturnType, PatchField, GeoMesh>> operator Op \
671( \
672 const Type1& t1, \
673 const GeometricField<Type2, PatchField, GeoMesh>& gf2 \
674) \
675{ \
676 return dimensioned<Type1>(t1) Op gf2; \
677} \
678 \
679 \
680TEMPLATE \
681tmp<GeometricField<ReturnType, PatchField, GeoMesh>> operator Op \
682( \
683 const dimensioned<Type1>& dt1, \
684 const tmp<GeometricField<Type2, PatchField, GeoMesh>>& tgf2 \
685) \
686{ \
687 const GeometricField<Type2, PatchField, GeoMesh>& gf2 = tgf2(); \
688 \
689 auto tres = \
690 reuseTmpGeometricField<ReturnType, Type2, PatchField, GeoMesh>::New \
691 ( \
692 tgf2, \
693 '(' + dt1.name() + OpName + gf2.name() + ')', \
694 dt1.dimensions() Op gf2.dimensions() \
695 ) ; \
696 \
697 Foam::OpFunc(tres.ref(), dt1, gf2); \
698 \
699 tgf2.clear(); \
700 \
701 return tres; \
702} \
703 \
704 \
705TEMPLATE \
706tmp<GeometricField<ReturnType, PatchField, GeoMesh>> operator Op \
707( \
708 const Type1& t1, \
709 const tmp<GeometricField<Type2, PatchField, GeoMesh>>& tgf2 \
710) \
711{ \
712 return dimensioned<Type1>(t1) Op tgf2; \
713}
714
715
716#define BINARY_TYPE_OPERATOR_FS(ReturnType, Type1, Type2, Op, OpName, OpFunc) \
717 \
718TEMPLATE \
719void OpFunc \
720( \
721 GeometricField<ReturnType, PatchField, GeoMesh>& res, \
722 const GeometricField<Type1, PatchField, GeoMesh>& gf1, \
723 const dimensioned<Type2>& dt2 \
724) \
725{ \
726 Foam::OpFunc(res.primitiveFieldRef(), gf1.primitiveField(), dt2.value()); \
727 Foam::OpFunc(res.boundaryFieldRef(), gf1.boundaryField(), dt2.value()); \
728 res.oriented() = gf1.oriented(); \
729} \
730 \
731 \
732TEMPLATE \
733tmp<GeometricField<ReturnType, PatchField, GeoMesh>> operator Op \
734( \
735 const GeometricField<Type1, PatchField, GeoMesh>& gf1, \
736 const dimensioned<Type2>& dt2 \
737) \
738{ \
739 auto tres = \
740 tmp<GeometricField<ReturnType, PatchField, GeoMesh>>::New \
741 ( \
742 IOobject \
743 ( \
744 '(' + gf1.name() + OpName + dt2.name() + ')', \
745 gf1.instance(), \
746 gf1.db(), \
747 IOobject::NO_READ, \
748 IOobject::NO_WRITE \
749 ), \
750 gf1.mesh(), \
751 gf1.dimensions() Op dt2.dimensions() \
752 ); \
753 \
754 Foam::OpFunc(tres.ref(), gf1, dt2); \
755 \
756 return tres; \
757} \
758 \
759 \
760TEMPLATE \
761tmp<GeometricField<ReturnType, PatchField, GeoMesh>> operator Op \
762( \
763 const GeometricField<Type1, PatchField, GeoMesh>& gf1, \
764 const Type2& t2 \
765) \
766{ \
767 return gf1 Op dimensioned<Type2>(t2); \
768} \
769 \
770 \
771TEMPLATE \
772tmp<GeometricField<ReturnType, PatchField, GeoMesh>> operator Op \
773( \
774 const tmp<GeometricField<Type1, PatchField, GeoMesh>>& tgf1, \
775 const dimensioned<Type2>& dt2 \
776) \
777{ \
778 const GeometricField<Type1, PatchField, GeoMesh>& gf1 = tgf1(); \
779 \
780 auto tres = \
781 reuseTmpGeometricField<ReturnType, Type1, PatchField, GeoMesh>::New \
782 ( \
783 tgf1, \
784 '(' + gf1.name() + OpName + dt2.name() + ')', \
785 gf1.dimensions() Op dt2.dimensions() \
786 ); \
787 \
788 Foam::OpFunc(tres.ref(), gf1, dt2); \
789 \
790 tgf1.clear(); \
791 \
792 return tres; \
793} \
794 \
795 \
796TEMPLATE \
797tmp<GeometricField<ReturnType, PatchField, GeoMesh>> operator Op \
798( \
799 const tmp<GeometricField<Type1, PatchField, GeoMesh>>& tgf1, \
800 const Type2& t2 \
801) \
802{ \
803 return tgf1 Op dimensioned<Type2>(t2); \
804}
805
806
807#define BINARY_TYPE_OPERATOR(ReturnType, Type1, Type2, Op, OpName, OpFunc) \
808 BINARY_TYPE_OPERATOR_SF(ReturnType, Type1, Type2, Op, OpName, OpFunc) \
809 BINARY_TYPE_OPERATOR_FS(ReturnType, Type1, Type2, Op, OpName, OpFunc)
810
811
812// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
813
814} // End namespace Foam
815
816// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
Foam
Namespace for OpenFOAM.
Definition: atmBoundaryLayer.C:34