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