Loading...
Searching...
No Matches
DimensionedFieldFunctions.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-2025 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 "DimensionedFieldReuseFunctions.H"
30
31#define TEMPLATE template<class Type, class GeoMesh>
32#include "DimensionedFieldFunctionsM.C"
33
34// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
35
36namespace Foam
37{
38
39// * * * * * * * * * * * * * * * Global Functions * * * * * * * * * * * * * //
40
41template<class Type, class GeoMesh, direction r>
42tmp<DimensionedField<typename powProduct<Type, r>::type, GeoMesh>>
43pow
44(
45 const DimensionedField<Type, GeoMesh>& f1,
46 typename powProduct<Type, r>::type
47)
48{
49 typedef typename powProduct<Type, r>::type resultType;
50
51 auto tres =
52 reuseTmpDimensionedField<resultType, Type, GeoMesh>::New
53 (
54 f1,
55 "pow(" + f1.name() + ',' + Foam::name(r) + ')',
56 pow(f1.dimensions(), r)
57 );
58
59 pow<Type, r, GeoMesh>(tres.ref().field(), f1.field());
60
61 return tres;
62}
63
64
65template<class Type, class GeoMesh, direction r>
66tmp<DimensionedField<typename powProduct<Type, r>::type, GeoMesh>>
67pow
68(
69 const tmp<DimensionedField<Type, GeoMesh>>& tf1,
70 typename powProduct<Type, r>::type
71)
72{
73 typedef typename powProduct<Type, r>::type resultType;
74
75 const auto& f1 = tf1();
76
77 auto tres =
78 reuseTmpDimensionedField<resultType, Type, GeoMesh>::New
79 (
80 tf1,
81 "pow(" + f1.name() + ',' + Foam::name(r) + ')',
82 pow(f1.dimensions(), r)
83 );
84
85 pow<Type, r, GeoMesh>(tres.ref().field(), f1.field());
86
87 tf1.clear();
88 return tres;
89}
90
91
92template<class Type, class GeoMesh>
93tmp<DimensionedField<typename outerProduct<Type, Type>::type, GeoMesh>>
94sqr(const DimensionedField<Type, GeoMesh>& f1)
95{
96 typedef typename outerProduct<Type, Type>::type resultType;
97
98 auto tres =
99 reuseTmpDimensionedField<resultType, Type, GeoMesh>::New
100 (
101 f1,
102 "sqr(" + f1.name() + ')',
103 sqr(f1.dimensions())
104 );
105
106 sqr(tres.ref().field(), f1.field());
107
108 return tres;
109}
110
111template<class Type, class GeoMesh>
112tmp<DimensionedField<typename outerProduct<Type, Type>::type, GeoMesh>>
113sqr(const tmp<DimensionedField<Type, GeoMesh>>& tf1)
114{
115 typedef typename outerProduct<Type, Type>::type resultType;
116
117 const auto& f1 = tf1();
118
119 auto tres =
120 reuseTmpDimensionedField<resultType, Type, GeoMesh>::New
121 (
122 tf1,
123 "sqr(" + f1.name() + ')',
124 sqr(f1.dimensions())
125 );
126
127 sqr(tres.ref().field(), f1.field());
128
129 tf1.clear();
130 return tres;
131}
132
133
134template<class Type, class GeoMesh>
135tmp<DimensionedField<typename typeOfMag<Type>::type, GeoMesh>>
136magSqr(const DimensionedField<Type, GeoMesh>& f1)
137{
138 typedef typename typeOfMag<Type>::type resultType;
139
140 auto tres =
141 reuseTmpDimensionedField<resultType, Type, GeoMesh>::New
142 (
143 f1,
144 "magSqr(" + f1.name() + ')',
145 sqr(f1.dimensions())
146 );
147
148 magSqr(tres.ref().field(), f1.field());
149
150 return tres;
151}
152
153template<class Type, class GeoMesh>
154tmp<DimensionedField<typename typeOfMag<Type>::type, GeoMesh>>
155magSqr(const tmp<DimensionedField<Type, GeoMesh>>& tf1)
156{
157 typedef typename typeOfMag<Type>::type resultType;
158
159 const auto& f1 = tf1();
160
161 auto tres =
162 reuseTmpDimensionedField<resultType, Type, GeoMesh>::New
163 (
164 tf1,
165 "magSqr(" + f1.name() + ')',
166 sqr(f1.dimensions())
167 );
168
169 magSqr(tres.ref().field(), f1.field());
170
171 tf1.clear();
172 return tres;
173}
174
175
176template<class Type, class GeoMesh>
177tmp<DimensionedField<typename typeOfMag<Type>::type, GeoMesh>>
178mag(const DimensionedField<Type, GeoMesh>& f1)
179{
180 typedef typename typeOfMag<Type>::type resultType;
181
182 auto tres =
183 reuseTmpDimensionedField<resultType, Type, GeoMesh>::New
184 (
185 f1,
186 "mag(" + f1.name() + ')',
187 f1.dimensions()
188 );
189
190 mag(tres.ref().field(), f1.field());
191
192 return tres;
193}
194
195template<class Type, class GeoMesh>
196tmp<DimensionedField<typename typeOfMag<Type>::type, GeoMesh>>
197mag(const tmp<DimensionedField<Type, GeoMesh>>& tf1)
198{
199 typedef typename typeOfMag<Type>::type resultType;
200
201 const auto& f1 = tf1();
202
203 auto tres =
204 reuseTmpDimensionedField<resultType, Type, GeoMesh>::New
205 (
206 tf1,
207 "mag(" + f1.name() + ')',
208 f1.dimensions()
209 );
210
211 mag(tres.ref().field(), f1.field());
212
213 tf1.clear();
214 return tres;
215}
216
217
218template<class Type, class GeoMesh>
219tmp
220<
221 DimensionedField
222 <
223 typename DimensionedField<Type, GeoMesh>::cmptType, GeoMesh
224 >
225>
226cmptAv(const DimensionedField<Type, GeoMesh>& f1)
227{
228 typedef typename DimensionedField<Type, GeoMesh>::cmptType resultType;
229
230 auto tres =
231 reuseTmpDimensionedField<resultType, Type, GeoMesh>::New
232 (
233 f1,
234 "cmptAv(" + f1.name() + ')',
235 f1.dimensions()
236 );
237
238 cmptAv(tres.ref().field(), f1.field());
239
240 return tres;
241}
242
243
244template<class Type, class GeoMesh>
245tmp
246<
247 DimensionedField
248 <
249 typename DimensionedField<Type, GeoMesh>::cmptType, GeoMesh
250 >
251>
252cmptAv(const tmp<DimensionedField<Type, GeoMesh>>& tf1)
253{
254 typedef typename DimensionedField<Type, GeoMesh>::cmptType resultType;
255
256 const auto& f1 = tf1();
257
258 auto tres =
259 reuseTmpDimensionedField<resultType, Type, GeoMesh>::New
260 (
261 tf1,
262 "cmptAv(" + f1.name() + ')',
263 f1.dimensions()
264 );
265
266 cmptAv(tres.ref().field(), f1.field());
267
268 tf1.clear();
269 return tres;
270}
271
272
273#define UNARY_REDUCTION_FUNCTION(ReturnType, Func, gFunc) \
274 \
275template<class Type, class GeoMesh> \
276dimensioned<ReturnType> Func \
277( \
278 const DimensionedField<Type, GeoMesh>& f1, \
279 const label comm \
280) \
281{ \
282 return dimensioned<ReturnType> \
283 ( \
284 #Func "(" + f1.name() + ')', \
285 f1.dimensions(), \
286 gFunc(f1.field(), comm) \
287 ); \
288} \
289 \
290template<class Type, class GeoMesh> \
291dimensioned<ReturnType> Func \
292( \
293 const tmp<DimensionedField<Type, GeoMesh>>& tf1, \
294 const label comm \
295) \
296{ \
297 dimensioned<ReturnType> res = Func(tf1(), comm); \
298 tf1.clear(); \
299 return res; \
300}
301
302UNARY_REDUCTION_FUNCTION(Type, max, gMax)
303UNARY_REDUCTION_FUNCTION(Type, min, gMin)
304UNARY_REDUCTION_FUNCTION(Type, sum, gSum)
305UNARY_REDUCTION_FUNCTION(Type, average, gAverage)
306UNARY_REDUCTION_FUNCTION(MinMax<Type>, minMax, gMinMax)
307UNARY_REDUCTION_FUNCTION(scalarMinMax, minMaxMag, gMinMaxMag)
308
309UNARY_REDUCTION_FUNCTION(typename typeOfMag<Type>::type, sumMag, gSumMag)
310
311#undef UNARY_REDUCTION_FUNCTION
312
313
314BINARY_FUNCTION(Type, Type, Type, max)
315BINARY_FUNCTION(Type, Type, Type, min)
316BINARY_FUNCTION(Type, Type, Type, cmptMultiply)
317BINARY_FUNCTION(Type, Type, Type, cmptDivide)
318
319BINARY_TYPE_FUNCTION(Type, Type, Type, max)
320BINARY_TYPE_FUNCTION(Type, Type, Type, min)
321BINARY_TYPE_FUNCTION(Type, Type, Type, cmptMultiply)
322BINARY_TYPE_FUNCTION(Type, Type, Type, cmptDivide)
323
324
325// ------------------------------------------------------------------------- //
326
327// Clamp Methods
328
329template<class Type, class GeoMesh>
330void clamp
331(
332 DimensionedField<Type, GeoMesh>& result,
333 const DimensionedField<Type, GeoMesh>& f1,
334 Foam::zero_one
335)
336{
337 const MinMax<Type> range(Foam::zero_one{});
338
339 clamp(result.field(), f1.field(), range);
340 result.oriented() = f1.oriented();
341}
342
343template<class Type, class GeoMesh>
344tmp<DimensionedField<Type, GeoMesh>>
345clamp
346(
347 const DimensionedField<Type, GeoMesh>& f1,
348 Foam::zero_one
349)
350{
351 auto tres =
352 reuseTmpDimensionedField<Type, Type, GeoMesh>::New
353 (
354 f1,
355 "clamp01(" + f1.name() + ')',
356 f1.dimensions()
357 );
358
359 clamp(tres.ref(), f1, Foam::zero_one{});
360
361 return tres;
362}
363
364
365template<class Type, class GeoMesh>
366tmp<DimensionedField<Type, GeoMesh>>
367clamp
368(
369 const tmp<DimensionedField<Type, GeoMesh>>& tf1,
370 Foam::zero_one
371)
372{
373 const auto& f1 = tf1();
374
375 auto tres =
376 reuseTmpDimensionedField<Type, Type, GeoMesh>::New
377 (
378 tf1,
379 "clamp01(" + f1.name() + ')',
380 f1.dimensions()
381 );
382
383 clamp(tres.field(), f1, Foam::zero_one{});
384
385 tf1.clear();
386 return tres;
387}
388
389BINARY_TYPE_FUNCTION_FS(Type, Type, MinMax<Type>, clamp)
390
391
392// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
393
394TERNARY_FUNCTION(Type, Type, Type, scalar, lerp)
395TERNARY_TYPE_FUNCTION_FFS(Type, Type, Type, scalar, lerp)
396
397
398// * * * * * * * * * * * * * * * Global Operators * * * * * * * * * * * * * //
399
400UNARY_OPERATOR(Type, Type, -, negate, transform)
401
402BINARY_OPERATOR(Type, Type, scalar, *, '*', multiply)
403BINARY_OPERATOR(Type, scalar, Type, *, '*', multiply)
404BINARY_OPERATOR(Type, Type, scalar, /, '|', divide)
405
406BINARY_TYPE_OPERATOR_SF(Type, scalar, Type, *, '*', multiply)
407BINARY_TYPE_OPERATOR_FS(Type, Type, scalar, *, '*', multiply)
408
409BINARY_TYPE_OPERATOR_FS(Type, Type, scalar, /, '|', divide)
410
411
412// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
413
414#define PRODUCT_OPERATOR(product, Op, OpFunc) \
415 \
416template<class Type1, class Type2, class GeoMesh> \
417tmp<DimensionedField<typename product<Type1, Type2>::type, GeoMesh>> \
418operator Op \
419( \
420 const DimensionedField<Type1, GeoMesh>& f1, \
421 const DimensionedField<Type2, GeoMesh>& f2 \
422) \
423{ \
424 typedef typename product<Type1, Type2>::type resultType; \
425 \
426 auto tres = \
427 reuseTmpDimensionedField<resultType, Type1, GeoMesh>::New \
428 ( \
429 f1, \
430 '(' + f1.name() + #Op + f2.name() + ')', \
431 (f1.dimensions() Op f2.dimensions()) \
432 ); \
433 \
434 Foam::OpFunc(tres.ref().field(), f1.field(), f2.field()); \
435 \
436 return tres; \
437} \
438 \
439 \
440template<class Type1, class Type2, class GeoMesh> \
441tmp<DimensionedField<typename product<Type1, Type2>::type, GeoMesh>> \
442operator Op \
443( \
444 const DimensionedField<Type1, GeoMesh>& f1, \
445 const tmp<DimensionedField<Type2, GeoMesh>>& tf2 \
446) \
447{ \
448 typedef typename product<Type1, Type2>::type resultType; \
449 \
450 const auto& f2 = tf2(); \
451 \
452 auto tres = \
453 reuseTmpDimensionedField<resultType, Type2, GeoMesh>::New \
454 ( \
455 tf2, \
456 '(' + f1.name() + #Op + f2.name() + ')', \
457 (f1.dimensions() Op f2.dimensions()) \
458 ); \
459 \
460 Foam::OpFunc(tres.ref().field(), f1.field(), f2.field()); \
461 \
462 tf2.clear(); \
463 return tres; \
464} \
465 \
466 \
467template<class Type1, class Type2, class GeoMesh> \
468tmp<DimensionedField<typename product<Type1, Type2>::type, GeoMesh>> \
469operator Op \
470( \
471 const tmp<DimensionedField<Type1, GeoMesh>>& tf1, \
472 const DimensionedField<Type2, GeoMesh>& f2 \
473) \
474{ \
475 typedef typename product<Type1, Type2>::type resultType; \
476 \
477 const auto& f1 = tf1(); \
478 \
479 auto tres = \
480 reuseTmpDimensionedField<resultType, Type1, GeoMesh>::New \
481 ( \
482 tf1, \
483 '(' + f1.name() + #Op + f2.name() + ')', \
484 (f1.dimensions() Op f2.dimensions()) \
485 ); \
486 \
487 Foam::OpFunc(tres.ref().field(), f1.field(), f2.field()); \
488 \
489 tf1.clear(); \
490 return tres; \
491} \
492 \
493 \
494template<class Type1, class Type2, class GeoMesh> \
495tmp<DimensionedField<typename product<Type1, Type2>::type, GeoMesh>> \
496operator Op \
497( \
498 const tmp<DimensionedField<Type1, GeoMesh>>& tf1, \
499 const tmp<DimensionedField<Type2, GeoMesh>>& tf2 \
500) \
501{ \
502 typedef typename product<Type1, Type2>::type resultType; \
503 \
504 const auto& f1 = tf1(); \
505 const auto& f2 = tf2(); \
506 \
507 auto tres = \
508 reuseTmpTmpDimensionedField \
509 <resultType, Type1, Type1, Type2, GeoMesh>::New \
510 ( \
511 tf1, \
512 tf2, \
513 '(' + f1.name() + #Op + f2.name() + ')', \
514 (f1.dimensions() Op f2.dimensions()) \
515 ); \
516 \
517 Foam::OpFunc(tres.ref().field(), f1.field(), f2.field()); \
518 \
519 tf1.clear(); \
520 tf2.clear(); \
521 return tres; \
522} \
523 \
524 \
525template<class Form, class Type, class GeoMesh> \
526tmp<DimensionedField<typename product<Type, Form>::type, GeoMesh>> \
527operator Op \
528( \
529 const DimensionedField<Type, GeoMesh>& f1, \
530 const dimensioned<Form>& dvs \
531) \
532{ \
533 typedef typename product<Type, Form>::type resultType; \
534 \
535 auto tres = \
536 reuseTmpDimensionedField<resultType, Type, GeoMesh>::New \
537 ( \
538 f1, \
539 '(' + f1.name() + #Op + dvs.name() + ')', \
540 (f1.dimensions() Op dvs.dimensions()) \
541 ); \
542 \
543 Foam::OpFunc(tres.ref().field(), f1.field(), dvs.value()); \
544 \
545 return tres; \
546} \
547 \
548 \
549template<class Form, class Cmpt, direction nCmpt, class Type, class GeoMesh> \
550tmp<DimensionedField<typename product<Form, Type>::type, GeoMesh>> \
551operator Op \
552( \
553 const DimensionedField<Type, GeoMesh>& f1, \
554 const VectorSpace<Form,Cmpt,nCmpt>& vs \
555) \
556{ \
557 return f1 Op dimensioned<Form>(static_cast<const Form&>(vs)); \
558} \
559 \
560 \
561template<class Form, class Type, class GeoMesh> \
562tmp<DimensionedField<typename product<Type, Form>::type, GeoMesh>> \
563operator Op \
564( \
565 const tmp<DimensionedField<Type, GeoMesh>>& tf1, \
566 const dimensioned<Form>& dvs \
567) \
568{ \
569 typedef typename product<Type, Form>::type resultType; \
570 \
571 const auto& f1 = tf1(); \
572 \
573 auto tres = \
574 reuseTmpDimensionedField<resultType, Type, GeoMesh>::New \
575 ( \
576 tf1, \
577 '(' + f1.name() + #Op + dvs.name() + ')', \
578 (f1.dimensions() Op dvs.dimensions()) \
579 ); \
580 \
581 Foam::OpFunc(tres.ref().field(), f1.field(), dvs.value()); \
582 \
583 tf1.clear(); \
584 return tres; \
585} \
586 \
587 \
588template<class Form, class Cmpt, direction nCmpt, class Type, class GeoMesh> \
589tmp<DimensionedField<typename product<Form, Type>::type, GeoMesh>> \
590operator Op \
591( \
592 const tmp<DimensionedField<Type, GeoMesh>>& tf1, \
593 const VectorSpace<Form,Cmpt,nCmpt>& vs \
594) \
595{ \
596 return tf1 Op dimensioned<Form>(static_cast<const Form&>(vs)); \
597} \
598 \
599 \
600template<class Form, class Type, class GeoMesh> \
601tmp<DimensionedField<typename product<Form, Type>::type, GeoMesh>> \
602operator Op \
603( \
604 const dimensioned<Form>& dvs, \
605 const DimensionedField<Type, GeoMesh>& f2 \
606) \
607{ \
608 typedef typename product<Form, Type>::type resultType; \
609 \
610 auto tres = \
611 reuseTmpDimensionedField<resultType, Type, GeoMesh>::New \
612 ( \
613 f2, \
614 '(' + dvs.name() + #Op + f2.name() + ')', \
615 (dvs.dimensions() Op f2.dimensions()) \
616 ); \
617 \
618 Foam::OpFunc(tres.ref().field(), dvs.value(), f2.field()); \
619 \
620 return tres; \
621} \
622 \
623 \
624template<class Form, class Cmpt, direction nCmpt, class Type, class GeoMesh> \
625tmp<DimensionedField<typename product<Form, Type>::type, GeoMesh>> \
626operator Op \
627( \
628 const VectorSpace<Form,Cmpt,nCmpt>& vs, \
629 const DimensionedField<Type, GeoMesh>& f2 \
630) \
631{ \
632 return dimensioned<Form>(static_cast<const Form&>(vs)) Op f2; \
633} \
634 \
635 \
636template<class Form, class Type, class GeoMesh> \
637tmp<DimensionedField<typename product<Form, Type>::type, GeoMesh>> \
638operator Op \
639( \
640 const dimensioned<Form>& dvs, \
641 const tmp<DimensionedField<Type, GeoMesh>>& tf2 \
642) \
643{ \
644 typedef typename product<Form, Type>::type resultType; \
645 \
646 const auto& f2 = tf2(); \
647 \
648 auto tres = \
649 reuseTmpDimensionedField<resultType, Type, GeoMesh>::New \
650 ( \
651 tf2, \
652 '(' + dvs.name() + #Op + f2.name() + ')', \
653 (dvs.dimensions() Op f2.dimensions()) \
654 ); \
655 \
656 Foam::OpFunc(tres.ref().field(), dvs.value(), f2.field()); \
657 \
658 tf2.clear(); \
659 return tres; \
660} \
661 \
662 \
663template<class Form, class Cmpt, direction nCmpt, class Type, class GeoMesh> \
664tmp<DimensionedField<typename product<Form, Type>::type, GeoMesh>> \
665operator Op \
666( \
667 const VectorSpace<Form,Cmpt,nCmpt>& vs, \
668 const tmp<DimensionedField<Type, GeoMesh>>& tf2 \
669) \
670{ \
671 return dimensioned<Form>(static_cast<const Form&>(vs)) Op tf2; \
672}
673
674
675PRODUCT_OPERATOR(typeOfSum, +, add)
676PRODUCT_OPERATOR(typeOfSum, -, subtract)
677
678PRODUCT_OPERATOR(outerProduct, *, outer)
679PRODUCT_OPERATOR(crossProduct, ^, cross)
680PRODUCT_OPERATOR(innerProduct, &, dot)
681PRODUCT_OPERATOR(scalarProduct, &&, dotdot)
682
683#undef PRODUCT_OPERATOR
684
685
686// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
687
688} // End namespace Foam
689
690// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
691
692#include "undefFieldFunctionsM.H"
693
694// ************************************************************************* //
BINARY_FUNCTION
#define BINARY_FUNCTION(ReturnType, Type1, Type2, Func)
Definition DimensionedFieldFunctionsM.C:140
BINARY_TYPE_FUNCTION_FS
#define BINARY_TYPE_FUNCTION_FS(ReturnType, Type1, Type2, Func)
Definition DimensionedFieldFunctionsM.C:329
UNARY_OPERATOR
#define UNARY_OPERATOR(ReturnType, Type1, Op, OpFunc, Dfunc)
Definition DimensionedFieldFunctionsM.C:83
BINARY_OPERATOR
#define BINARY_OPERATOR(ReturnType, Type1, Type2, Op, OpName, OpFunc)
Definition DimensionedFieldFunctionsM.C:416
TERNARY_FUNCTION
#define TERNARY_FUNCTION(ReturnType, Type1, Type2, Type3, Func)
Definition DimensionedFieldFunctionsM.C:692
TERNARY_TYPE_FUNCTION_FFS
#define TERNARY_TYPE_FUNCTION_FFS(ReturnType, Type1, Type2, Type3, Func)
Definition DimensionedFieldFunctionsM.C:910
BINARY_TYPE_OPERATOR_SF
#define BINARY_TYPE_OPERATOR_SF(ReturnType, Type1, Type2, Op, OpName, OpFunc)
Definition DimensionedFieldFunctionsM.C:526
BINARY_TYPE_OPERATOR_FS
#define BINARY_TYPE_OPERATOR_FS(ReturnType, Type1, Type2, Op, OpName, OpFunc)
Definition DimensionedFieldFunctionsM.C:606
BINARY_TYPE_FUNCTION
#define BINARY_TYPE_FUNCTION(ReturnType, Type1, Type2, Func)
Definition DimensionedFieldFunctionsM.C:409
UNARY_REDUCTION_FUNCTION
#define UNARY_REDUCTION_FUNCTION(ReturnType, Func, gFunc)
Definition DimensionedFieldFunctions.C:266
range
scalar range
Definition LISASMDCalcMethod1.H:12
Foam::DimensionedField
Field with dimensions and associated with geometry type GeoMesh which is used to size the field and a...
Definition DimensionedField.H:76
Foam::DimensionedField::field
const DynamicField< Type > & field() const noexcept
Return const-reference to the primitive field values.
Definition DimensionedField.H:723
Foam::DimensionedField::dimensions
const dimensionSet & dimensions() const noexcept
Return dimensions.
Definition DimensionedField.H:693
Foam::DimensionedField::cmptType
Field< Type >::cmptType cmptType
Component type of the field elements.
Definition DimensionedField.H:104
Foam::GeoMesh
Generic mesh wrapper used by volMesh, surfaceMesh, pointMesh etc.
Definition GeoMesh.H:46
Foam::IOobject::name
const word & name() const noexcept
Return the object name.
Definition IOobjectI.H:205
Foam::MinMax
A min/max value pair with additional methods. In addition to conveniently storing values,...
Definition MinMax.H:106
Foam::outerProduct::type
typeOfRank< typenamepTraits< arg1 >::cmptType, direction(pTraits< arg1 >::rank)+direction(pTraits< arg2 >::rank)>::type type
Definition products.H:118
Foam::powProduct::type
symmTypeOfRank< typenamepTraits< arg1 >::cmptType, arg2 *direction(pTraits< arg1 >::rank)>::type type
Definition products.H:176
Foam::tmp
A class for managing temporary objects.
Definition tmp.H:75
Foam::typeOfMag
The magnitude type for given argument.
Definition products.H:93
Foam::typeOfMag::type
pTraits< typenamepTraits< arg1 >::cmptType >::magType type
Definition products.H:96
Foam::zero_one
Represents 0/1 range or concept. Used for tagged dispatch or clamping.
Definition pTraits.H:51
PRODUCT_OPERATOR
#define PRODUCT_OPERATOR(product, op, opFunc)
Definition dimensionedType.C:888
Foam
Namespace for OpenFOAM.
Definition atmBoundaryLayer.C:27
Foam::gAverage
Type gAverage(const FieldField< Field, Type > &f, const label comm)
The global arithmetic average of a FieldField.
Definition FieldFieldFunctions.C:590
Foam::minMaxMag
dimensioned< scalarMinMax > minMaxMag(const DimensionedField< Type, GeoMesh > &f1, const label comm)
Definition DimensionedFieldFunctions.C:300
Foam::max
label max(const labelHashSet &set, label maxValue=labelMin)
Find the max value in labelHashSet, optionally limited by second argument.
Definition hashSets.C:40
Foam::gSum
Type gSum(const FieldField< Field, Type > &f)
Definition FieldFieldFunctions.C:579
Foam::sqr
dimensionedSymmTensor sqr(const dimensionedVector &dv)
Definition dimensionedSymmTensor.C:44
Foam::subtract
void subtract(DimensionedField< scalar, GeoMesh > &result, const dimensioned< scalar > &dt1, const DimensionedField< scalar, GeoMesh > &f2)
Foam::cmptDivide
dimensioned< Type > cmptDivide(const dimensioned< Type > &, const dimensioned< Type > &)
Foam::transform
refinementData transform(const tensor &, const refinementData val)
No-op rotational transform for base types.
Definition refinementData.C:26
Foam::clamp
dimensionSet clamp(const dimensionSet &a, const dimensionSet &range)
Definition dimensionSet.C:271
Foam::divide
void divide(DimensionedField< Type, GeoMesh > &result, const DimensionedField< Type, GeoMesh > &f1, const DimensionedField< scalar, GeoMesh > &f2)
Definition DimensionedFieldFunctions.C:397
Foam::scalarMinMax
MinMax< scalar > scalarMinMax
A scalar min/max range.
Definition MinMax.H:97
Foam::dot
void dot(FieldField< Field1, typename innerProduct< Type1, Type2 >::type > &f, const FieldField< Field1, Type1 > &f1, const FieldField< Field2, Type2 > &f2)
Definition FieldFieldFunctions.C:932
Foam::gMinMaxMag
scalarMinMax gMinMaxMag(const FieldField< Field, Type > &f)
Definition FieldFieldFunctions.C:581
Foam::pow
dimensionedScalar pow(const dimensionedScalar &ds, const dimensionedScalar &expt)
Definition dimensionedScalar.C:68
Foam::minMax
MinMax< label > minMax(const labelHashSet &set)
Find the min/max values of labelHashSet.
Definition hashSets.C:54
Foam::add
void add(DimensionedField< scalar, GeoMesh > &result, const dimensioned< scalar > &dt1, const DimensionedField< scalar, GeoMesh > &f2)
Foam::cmptAv
tmp< DimensionedField< typename DimensionedField< Type, GeoMesh >::cmptType, GeoMesh > > cmptAv(const DimensionedField< Type, GeoMesh > &f1)
Definition DimensionedFieldFunctions.C:219
Foam::mag
dimensioned< typename typeOfMag< Type >::type > mag(const dimensioned< Type > &dt)
Foam::min
label min(const labelHashSet &set, label minValue=labelMax)
Find the min value in labelHashSet, optionally limited by second argument.
Definition hashSets.C:26
Foam::gMinMax
MinMax< Type > gMinMax(const FieldField< Field, Type > &f)
Definition FieldFieldFunctions.C:580
Foam::sum
dimensioned< Type > sum(const DimensionedField< Type, GeoMesh > &f1, const label comm)
Definition DimensionedFieldFunctions.C:297
Foam::cmptMultiply
dimensioned< Type > cmptMultiply(const dimensioned< Type > &, const dimensioned< Type > &)
Foam::gSumMag
typeOfMag< Type >::type gSumMag(const FieldField< Field, Type > &f)
Definition FieldFieldFunctions.C:583
Foam::dotdot
void dotdot(FieldField< Field1, typename scalarProduct< Type1, Type2 >::type > &f, const FieldField< Field1, Type1 > &f1, const FieldField< Field2, Type2 > &f2)
Definition FieldFieldFunctions.C:933
Foam::gMin
Type gMin(const FieldField< Field, Type > &f)
Definition FieldFieldFunctions.C:578
Foam::name
word name(const expressions::valueTypeCode typeCode)
A word representation of a valueTypeCode. Empty for expressions::valueTypeCode::INVALID.
Definition exprTraits.C:127
Foam::cross
void cross(FieldField< Field1, typename crossProduct< Type1, Type2 >::type > &f, const FieldField< Field1, Type1 > &f1, const FieldField< Field2, Type2 > &f2)
Definition FieldFieldFunctions.C:931
Foam::negate
void negate(DimensionedField< Type, GeoMesh > &result, const DimensionedField< Type, GeoMesh > &f1)
Definition DimensionedFieldFunctions.C:393
Foam::multiply
void multiply(DimensionedField< Type, GeoMesh > &result, const DimensionedField< Type, GeoMesh > &f1, const DimensionedField< scalar, GeoMesh > &f2)
Definition DimensionedFieldFunctions.C:395
Foam::average
dimensioned< Type > average(const DimensionedField< Type, GeoMesh > &f1, const label comm)
Definition DimensionedFieldFunctions.C:298
Foam::gMax
Type gMax(const FieldField< Field, Type > &f)
Definition FieldFieldFunctions.C:577
Foam::magSqr
dimensioned< typename typeOfMag< Type >::type > magSqr(const dimensioned< Type > &dt)
Foam::outer
void outer(FieldField< Field1, typename outerProduct< Type1, Type2 >::type > &f, const FieldField< Field1, Type1 > &f1, const FieldField< Field2, Type2 > &f2)
Definition FieldFieldFunctions.C:930
Foam::lerp
dimensioned< Type > lerp(const dimensioned< Type > &a, const dimensioned< Type > &b, const scalar t)
Foam::sumMag
dimensioned< typename typeOfMag< Type >::type > sumMag(const DimensionedField< Type, GeoMesh > &f1, const label comm)
Definition DimensionedFieldFunctions.C:302
Foam::reuseTmpDimensionedField::New
static tmp< DimensionedField< TypeR, GeoMesh > > New(const DimensionedField< Type1, GeoMesh > &f1, const word &name, const dimensionSet &dimensions)
Pass-through to New DimensionedField.
Definition DimensionedFieldReuseFunctions.H:40