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