OpenFOAM
8
The OpenFOAM Foundation
•
All
Classes
Namespaces
Files
Functions
Variables
Typedefs
Enumerations
Enumerator
Friends
Macros
Pages
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
// ************************************************************************* //
DimensionedFieldReuseFunctions.H
src
OpenFOAM
fields
DimensionedFields
DimensionedField
DimensionedFieldFunctionsM.C
Generated by
1.8.13
1.8.13 
