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