FieldFunctions.H
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 -------------------------------------------------------------------------------
11 License
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 #define TEMPLATE template<class Type>
30 #include "FieldFunctionsM.H"
31 #include "UPstream.H"
32 #include "MinMax.H"
33 
34 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
35 
36 namespace Foam
37 {
38 
39 // * * * * * * * * * * * * * * * Global Functions * * * * * * * * * * * * * //
40 
41 template<class Type>
42 void component
43 (
44  Field<typename Field<Type>::cmptType>& res,
45  const UList<Type>& f,
46  const direction d
47 );
48 
49 
50 template<class Type>
51 void T(Field<Type>& res, const UList<Type>& f);
52 
53 
54 template<class Type, direction r>
55 void pow
56 (
57  Field<typename powProduct<Type, r>::type>& res,
58  const UList<Type>& vf
59 );
60 
61 
62 template<class Type, direction r>
63 tmp<Field<typename powProduct<Type, r>::type>>
64 pow
65 (
66  const UList<Type>& f,
67  typename powProduct<Type, r>::type
68  = pTraits<typename powProduct<Type, r>::type>::zero
69 );
70 
71 template<class Type, direction r>
72 tmp<Field<typename powProduct<Type, r>::type>>
73 pow
74 (
75  const tmp<Field<Type>>& tf,
76  typename powProduct<Type, r>::type
77  = pTraits<typename powProduct<Type, r>::type>::zero
78 );
79 
80 
81 template<class Type>
82 void sqr
83 (
84  Field<typename outerProduct<Type, Type>::type>& res,
85  const UList<Type>& vf
86 );
87 
88 template<class Type>
89 tmp<Field<typename outerProduct<Type, Type>::type>>
90 sqr(const UList<Type>& f);
91 
92 template<class Type>
93 tmp<Field<typename outerProduct<Type, Type>::type>>
94 sqr(const tmp<Field<Type>>& tf);
95 
96 
97 template<class Type>
98 void magSqr
99 (
100  Field<typename typeOfMag<Type>::type>& res,
101  const UList<Type>& f
102 );
103 
104 template<class Type>
105 tmp<Field<typename typeOfMag<Type>::type>>
106 magSqr(const UList<Type>& f);
107 
108 template<class Type>
109 tmp<Field<typename typeOfMag<Type>::type>>
110 magSqr(const tmp<Field<Type>>& tf);
111 
112 
113 template<class Type>
114 void mag
115 (
116  Field<typename typeOfMag<Type>::type>& res,
117  const UList<Type>& f
118 );
119 
120 template<class Type>
121 tmp<Field<typename typeOfMag<Type>::type>>
122 mag(const UList<Type>& f);
123 
124 template<class Type>
125 tmp<Field<typename typeOfMag<Type>::type>>
126 mag(const tmp<Field<Type>>& tf);
127 
128 
129 template<class Type>
130 void cmptMax(Field<typename Field<Type>::cmptType>& res, const UList<Type>& f);
131 
132 template<class Type>
133 tmp<Field<typename Field<Type>::cmptType>> cmptMax(const UList<Type>& f);
134 
135 template<class Type>
136 tmp<Field<typename Field<Type>::cmptType>>
137 cmptMax(const tmp<Field<Type>>& tf);
138 
139 
140 template<class Type>
141 void cmptMin(Field<typename Field<Type>::cmptType>& res, const UList<Type>& f);
142 
143 template<class Type>
144 tmp<Field<typename Field<Type>::cmptType>> cmptMin(const UList<Type>& f);
145 
146 template<class Type>
147 tmp<Field<typename Field<Type>::cmptType>>
148 cmptMin(const tmp<Field<Type>>& tf);
149 
150 
151 template<class Type>
152 void cmptAv(Field<typename Field<Type>::cmptType>& res, const UList<Type>& f);
153 
154 template<class Type>
155 tmp<Field<typename Field<Type>::cmptType>> cmptAv(const UList<Type>& f);
156 
157 template<class Type>
158 tmp<Field<typename Field<Type>::cmptType>> cmptAv(const tmp<Field<Type>>& tf);
159 
160 
161 template<class Type>
162 void cmptMag(Field<Type>& res, const UList<Type>& f);
163 
164 template<class Type>
165 tmp<Field<Type>> cmptMag(const UList<Type>& f);
166 
167 template<class Type>
168 tmp<Field<Type>> cmptMag(const tmp<Field<Type>>& tf);
169 
170 
171 template<class Type>
172 void cmptMagSqr(Field<Type>& res, const UList<Type>& f);
173 
174 template<class Type>
175 tmp<Field<Type>> cmptMagSqr(const UList<Type>& f);
176 
177 template<class Type>
178 tmp<Field<Type>> cmptMagSqr(const tmp<Field<Type>>& tf);
179 
180 
181 #define TMP_UNARY_FUNCTION(ReturnType, Func) \
182  \
183  \
184 template<class Type> \
185 ReturnType Func(const tmp<Field<Type>>& tf1);
186 
187 template<class Type>
188 Type max(const UList<Type>& f);
189 
190 TMP_UNARY_FUNCTION(Type, max)
191 
192 template<class Type>
193 Type min(const UList<Type>& f);
194 
195 TMP_UNARY_FUNCTION(Type, min)
196 
197 template<class Type>
198 Type sum(const UList<Type>& f);
199 
200 TMP_UNARY_FUNCTION(Type, sum)
201 
202 
203 // From MinMaxOps.H:
204 // - Foam::minMax(const UList<Type>&)
205 // - Foam::minMaxMag(const UList<Type>&)
206 
207 TMP_UNARY_FUNCTION(MinMax<Type>, minMax)
208 TMP_UNARY_FUNCTION(scalarMinMax, minMaxMag)
209 
210 
211 template<class Type>
212 Type maxMagSqr(const UList<Type>& f);
213 
214 TMP_UNARY_FUNCTION(Type, maxMagSqr)
215 
216 template<class Type>
217 Type minMagSqr(const UList<Type>& f);
218 
219 TMP_UNARY_FUNCTION(Type, minMagSqr)
220 
221 
222 template<class Type>
223 typename scalarProduct<Type, Type>::type
224 sumProd
225 (
226  const UList<Type>& f1,
227  const UList<Type>& f2
228 );
229 
230 template<class Type>
231 Type sumCmptProd(const UList<Type>& f1, const UList<Type>& f2);
232 
233 template<class Type>
234 typename outerProduct1<Type>::type sumSqr(const UList<Type>& f);
235 
236 template<class Type>
237 typename outerProduct1<Type>::type sumSqr(const tmp<Field<Type>>& tf);
238 
239 template<class Type>
240 typename typeOfMag<Type>::type sumMag(const UList<Type>& f);
241 
242 TMP_UNARY_FUNCTION(typename typeOfMag<Type>::type, sumMag)
243 
244 template<class Type>
245 Type sumCmptMag(const UList<Type>& f);
246 
247 TMP_UNARY_FUNCTION(Type, sumCmptMag)
248 
249 //- The local arithmetic average of a field
250 template<class Type>
251 Type average(const UList<Type>& f);
252 
253 TMP_UNARY_FUNCTION(Type, average)
254 
255 
256 // With reduction on ReturnType
257 #define G_UNARY_FUNCTION(ReturnType, gFunc, Func, rFunc) \
258  \
259 template<class Type> \
260 ReturnType gFunc(const UList<Type>& f, const label comm = UPstream::worldComm);\
261 TMP_UNARY_FUNCTION(ReturnType, gFunc)
262 
263 G_UNARY_FUNCTION(Type, gMax, max, max)
264 G_UNARY_FUNCTION(Type, gMin, min, min)
265 G_UNARY_FUNCTION(Type, gSum, sum, sum)
266 G_UNARY_FUNCTION(Type, gMaxMagSqr, maxMagSqr, maxMagSqr)
267 G_UNARY_FUNCTION(Type, gMinMagSqr, minMagSqr, minMagSqr)
268 G_UNARY_FUNCTION(Type, gSumCmptMag, sumCmptMag, sum)
269 
270 G_UNARY_FUNCTION(MinMax<Type>, gMinMax, minMax, sum)
271 G_UNARY_FUNCTION(scalarMinMax, gMinMaxMag, minMaxMag, sum)
272 
273 G_UNARY_FUNCTION(typename outerProduct1<Type>::type, gSumSqr, sumSqr, sum)
274 G_UNARY_FUNCTION(typename typeOfMag<Type>::type, gSumMag, sumMag, sum)
275 
276 #undef G_UNARY_FUNCTION
277 
278 
279 template<class Type>
280 typename scalarProduct<Type, Type>::type gSumProd
281 (
282  const UList<Type>& f1,
283  const UList<Type>& f2,
284  const label comm = UPstream::worldComm
285 );
286 
287 template<class Type>
288 Type gSumCmptProd
289 (
290  const UList<Type>& f1,
291  const UList<Type>& f2,
292  const label comm = UPstream::worldComm
293 );
294 
295 //- The global arithmetic average of a field
296 template<class Type>
297 Type gAverage
298 (
299  const UList<Type>& f,
301  const label comm = UPstream::worldComm
302 );
303 
304 TMP_UNARY_FUNCTION(Type, gAverage)
305 
306 //- The global weighted average of a field,
307 //- using the mag() of the weights.
308 template<class Type>
309 Type gWeightedAverage
310 (
311  const UList<scalar>& weights,
312  const UList<Type>& fld,
314  const label comm = UPstream::worldComm
315 );
316 
317 //- The local weighted average of a field,
318 //- using the mag() of the weights.
319 template<class Type>
320 Type weightedAverage
321 (
322  const UList<scalar>& weights,
323  const UList<Type>& fld
324 )
325 {
326  // Use the global version, but without reduction
327  return gWeightedAverage(weights, fld, -1);
328 }
329 
330 //- The global weighted sum (integral) of a field,
331 //- using the mag() of the weights.
332 template<class Type>
333 Type gWeightedSum
334 (
335  const UList<scalar>& weights,
336  const UList<Type>& fld,
338  const label comm = UPstream::worldComm
339 );
340 
341 //- The local weighted sum (integral) of a field,
342 //- using the mag() of the weights.
343 template<class Type>
344 Type weightedSum
345 (
346  const UList<scalar>& weights,
347  const UList<Type>& fld
348 )
349 {
350  // Use the global version, but without reduction
351  return gWeightedSum(weights, fld, -1);
352 }
353 
354 
355 #undef TMP_UNARY_FUNCTION
356 
357 
358 BINARY_FUNCTION(Type, Type, Type, max)
359 BINARY_FUNCTION(Type, Type, Type, min)
360 BINARY_FUNCTION(Type, Type, Type, cmptMultiply)
361 BINARY_FUNCTION(Type, Type, Type, cmptDivide)
362 
363 BINARY_TYPE_FUNCTION(Type, Type, Type, max)
364 BINARY_TYPE_FUNCTION(Type, Type, Type, min)
365 BINARY_TYPE_FUNCTION(Type, Type, Type, cmptMultiply)
366 BINARY_TYPE_FUNCTION(Type, Type, Type, cmptDivide)
367 
368 BINARY_TYPE_FUNCTION_FS(Type, Type, MinMax<Type>, clamp)
369 BINARY_TYPE_FUNCTION_FS(Type, Type, Foam::zero_one, clamp)
370 
371 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
372 
373 TERNARY_FUNCTION(Type, Type, Type, scalar, lerp)
374 TERNARY_TYPE_FUNCTION_FFS(Type, Type, Type, scalar, lerp)
375 
376 
377 // * * * * * * * * * * * * * * * Global Operators * * * * * * * * * * * * * //
378 
379 UNARY_OPERATOR(Type, Type, -, negate)
380 
381 BINARY_OPERATOR(Type, Type, scalar, *, multiply)
382 BINARY_OPERATOR(Type, scalar, Type, *, multiply)
383 BINARY_OPERATOR(Type, Type, scalar, /, divide)
384 
385 BINARY_TYPE_OPERATOR_SF(Type, scalar, Type, *, multiply)
386 BINARY_TYPE_OPERATOR_FS(Type, Type, scalar, *, multiply)
387 
388 BINARY_TYPE_OPERATOR_FS(Type, Type, scalar, /, divide)
389 
390 
391 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
392 
393 #define PRODUCT_OPERATOR(product, Op, OpFunc) \
394  \
395 template<class Type1, class Type2> \
396 void OpFunc \
397 ( \
398  Field<typename product<Type1, Type2>::type>& res, \
399  const UList<Type1>& f1, \
400  const UList<Type2>& f2 \
401 ); \
402  \
403 template<class Type1, class Type2> \
404 tmp<Field<typename product<Type1, Type2>::type>> \
405 operator Op(const UList<Type1>& f1, const UList<Type2>& f2); \
406  \
407 template<class Type1, class Type2> \
408 tmp<Field<typename product<Type1, Type2>::type>> \
409 operator Op(const UList<Type1>& f1, const tmp<Field<Type2>>& tf2); \
410  \
411 template<class Type1, class Type2> \
412 tmp<Field<typename product<Type1, Type2>::type>> \
413 operator Op(const tmp<Field<Type1>>& tf1, const UList<Type2>& f2); \
414  \
415 template<class Type1, class Type2> \
416 tmp<Field<typename product<Type1, Type2>::type>> \
417 operator Op(const tmp<Field<Type1>>& tf1, const tmp<Field<Type2>>& tf2); \
418  \
419 template<class Type, class Form, class Cmpt, direction nCmpt> \
420 void OpFunc \
421 ( \
422  Field<typename product<Type, Form>::type>& res, \
423  const UList<Type>& f1, \
424  const VectorSpace<Form,Cmpt,nCmpt>& vs \
425 ); \
426  \
427 template<class Type, class Form, class Cmpt, direction nCmpt> \
428 tmp<Field<typename product<Type, Form>::type>> \
429 operator Op(const UList<Type>& f1, const VectorSpace<Form,Cmpt,nCmpt>& vs); \
430  \
431 template<class Type, class Form, class Cmpt, direction nCmpt> \
432 tmp<Field<typename product<Type, Form>::type>> \
433 operator Op(const tmp<Field<Type>>&tf1,const VectorSpace<Form,Cmpt,nCmpt>&vs); \
434  \
435 template<class Form, class Cmpt, direction nCmpt, class Type> \
436 void OpFunc \
437 ( \
438  Field<typename product<Form, Type>::type>& res, \
439  const VectorSpace<Form,Cmpt,nCmpt>& vs, \
440  const UList<Type>& f1 \
441 ); \
442  \
443 template<class Form, class Cmpt, direction nCmpt, class Type> \
444 tmp<Field<typename product<Form, Type>::type>> \
445 operator Op(const VectorSpace<Form,Cmpt,nCmpt>& vs, const UList<Type>& f1); \
446  \
447 template<class Form, class Cmpt, direction nCmpt, class Type> \
448 tmp<Field<typename product<Form, Type>::type>> \
449 operator Op(const VectorSpace<Form,Cmpt,nCmpt>&vs,const tmp<Field<Type>>&tf1);
450 
451 PRODUCT_OPERATOR(typeOfSum, +, add)
452 PRODUCT_OPERATOR(typeOfSum, -, subtract)
453 
454 PRODUCT_OPERATOR(outerProduct, *, outer)
455 PRODUCT_OPERATOR(crossProduct, ^, cross)
456 PRODUCT_OPERATOR(innerProduct, &, dot)
457 PRODUCT_OPERATOR(scalarProduct, &&, dotdot)
458 
459 #undef PRODUCT_OPERATOR
460 
461 
462 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
463 
464 } // End namespace Foam
465 
466 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
467 
468 #include "undefFieldFunctionsM.H"
469 #include "scalarField.H"
470 
471 // ************************************************************************* //
Foam::gWeightedAverage
Type gWeightedAverage(const UList< scalar > &weights, const UList< Type > &fld, const label comm)
The global weighted average of a field, using the mag() of the weights.
Definition: FieldFunctions.C:671
Foam::cmptMax
void cmptMax(FieldField< Field, typename FieldField< Field, Type >::cmptType > &cf, const FieldField< Field, Type > &f)
Definition: FieldFieldFunctions.C:236
BINARY_OPERATOR
#define BINARY_OPERATOR(ReturnType, Type1, Type2, Op, OpName, OpFunc)
Definition: DimensionedFieldFunctionsM.C:416
Foam::roots::type
type
Types of root.
Definition: Roots.H:52
Foam::divide
void divide(DimensionedField< Type, GeoMesh > &result, const DimensionedField< Type, GeoMesh > &f1, const DimensionedField< scalar, GeoMesh > &f2)
Foam::direction
uint8_t direction
Definition: direction.H:46
Foam::scalarMinMax
MinMax< scalar > scalarMinMax
A scalar min/max range.
Definition: MinMax.H:97
Foam::gWeightedSum
Type gWeightedSum(const UList< scalar > &weights, const UList< Type > &fld, const label comm)
The global weighted sum (integral) of a field, using the mag() of the weights.
Definition: FieldFunctions.C:710
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::weightedSum
Type weightedSum(const UList< scalar > &weights, const UList< Type > &fld)
The local weighted sum (integral) of a field, using the mag() of the weights.
Definition: FieldFunctions.H:350
Foam::gMin
Type gMin(const FieldField< Field, Type > &f)
Definition: FieldFieldFunctions.C:578
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::sqr
dimensionedSymmTensor sqr(const dimensionedVector &dv)
Definition: dimensionedSymmTensor.C:44
Foam::Field::cmptType
pTraits< Type >::cmptType cmptType
Component type.
Definition: Field.H:172
Foam::minMagSqr
Type minMagSqr(const UList< Type > &f1)
Definition: FieldFunctions.C:448
Foam::gSumProd
scalarProduct< Type, Type >::type gSumProd(const UList< Type > &f1, const UList< Type > &f2, const label comm)
Definition: FieldFunctions.C:613
BINARY_TYPE_OPERATOR_SF
#define BINARY_TYPE_OPERATOR_SF(ReturnType, Type1, Type2, Op, OpName, OpFunc)
Definition: DimensionedFieldFunctionsM.C:526
Foam::gSumCmptMag
Type gSumCmptMag(const UList< Type > &f, const label comm)
Definition: FieldFunctions.C:600
BINARY_TYPE_OPERATOR_FS
#define BINARY_TYPE_OPERATOR_FS(ReturnType, Type1, Type2, Op, OpName, OpFunc)
Definition: DimensionedFieldFunctionsM.C:606
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::outerProduct::type
typeOfRank< typename pTraits< arg1 >::cmptType, direction(pTraits< arg1 >::rank)+direction(pTraits< arg2 >::rank) >::type type
Definition: products.H:118
BINARY_TYPE_FUNCTION
#define BINARY_TYPE_FUNCTION(ReturnType, Type1, Type2, Func)
Definition: DimensionedFieldFunctionsM.C:409
Foam::UPstream::worldComm
static label worldComm
Communicator for all ranks. May differ from commGlobal() if local worlds are in use.
Definition: UPstream.H:987
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::subtract
void subtract(FieldField< Field1, typename typeOfSum< Type1, Type2 >::type > &f, const FieldField< Field1, Type1 > &f1, const FieldField< Field2, Type2 > &f2)
Definition: FieldFieldFunctions.C:928
Foam::sumCmptProd
Type sumCmptProd(const UList< Type > &f1, const UList< Type > &f2)
Definition: FieldFunctions.C:488
Foam::sum
dimensioned< Type > sum(const DimensionedField< Type, GeoMesh > &f1, const label comm)
Definition: DimensionedFieldFunctions.C:297
Foam::maxMagSqr
Type maxMagSqr(const UList< Type > &f1)
Definition: FieldFunctions.C:423
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
G_UNARY_FUNCTION
#define G_UNARY_FUNCTION(ReturnType, gFunc, Func, rFunc)
Definition: FieldFunctions.H:252
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::cmptDivide
dimensioned< Type > cmptDivide(const dimensioned< Type > &, const dimensioned< Type > &)
Foam::sumProd
complex sumProd(const UList< complex > &f1, const UList< complex > &f2)
Sum product.
Definition: complexField.C:245
Foam::minMax
MinMax< label > minMax(const labelHashSet &set)
Find the min/max values of labelHashSet.
Definition: hashSets.C:54
Foam::gMaxMagSqr
Type gMaxMagSqr(const UList< Type > &f, const label comm)
Definition: FieldFunctions.C:598
BINARY_FUNCTION
#define BINARY_FUNCTION(ReturnType, Type1, Type2, Func)
Definition: DimensionedFieldFunctionsM.C:140
Foam::average
dimensioned< Type > average(const DimensionedField< Type, GeoMesh > &f1, const label comm)
Definition: DimensionedFieldFunctions.C:298
Foam::minMaxMag
dimensioned< scalarMinMax > minMaxMag(const DimensionedField< Type, GeoMesh > &f1, const label comm)
Definition: DimensionedFieldFunctions.C:300
Foam::gMinMagSqr
Type gMinMagSqr(const UList< Type > &f, const label comm)
Definition: FieldFunctions.C:599
Foam::sumSqr
outerProduct1< Type >::type sumSqr(const UList< Type > &f1)
Definition: FieldFunctions.C:511
Foam::gSumCmptProd
Type gSumCmptProd(const UList< Type > &f1, const UList< Type > &f2, const label comm)
Definition: FieldFunctions.C:628
Foam::gSum
Type gSum(const FieldField< Field, Type > &f)
Definition: FieldFieldFunctions.C:579
Foam::cmptMagSqr
void cmptMagSqr(Field< Type > &result, const UList< Type > &f1)
Definition: FieldFunctions.C:332
Foam::weightedAverage
Type weightedAverage(const UList< scalar > &weights, const UList< Type > &fld)
The local weighted average of a field, using the mag() of the weights.
Definition: FieldFunctions.H:322
BINARY_TYPE_FUNCTION_FS
#define BINARY_TYPE_FUNCTION_FS(ReturnType, Type1, Type2, Func)
Definition: DimensionedFieldFunctionsM.C:329
Foam::gMinMax
MinMax< Type > gMinMax(const FieldField< Field, Type > &f)
Definition: FieldFieldFunctions.C:580
Foam::scalarProduct::type
pTraits< arg1 >::cmptType type
Definition: products.H:163
Foam::sumCmptMag
Type sumCmptMag(const UList< Type > &f1)
Definition: FieldFunctions.C:552
Foam::negate
void negate(DimensionedField< Type, GeoMesh > &result, const DimensionedField< Type, GeoMesh > &f1)
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::UList
A 1D vector of objects of type <T>, where the size of the vector is known and can be used for subscri...
Definition: HashTable.H:105
Foam::cmptMultiply
dimensioned< Type > cmptMultiply(const dimensioned< Type > &, const dimensioned< Type > &)
Foam::cmptMag
void cmptMag(FieldField< Field, Type > &cf, const FieldField< Field, Type > &f)
Definition: FieldFieldFunctions.C:371
FieldFunctionsM.H
Macro functions for Field<Type> algebra.
Foam::add
void add(FieldField< Field1, typename typeOfSum< Type1, Type2 >::type > &f, const FieldField< Field1, Type1 > &f1, const FieldField< Field2, Type2 > &f2)
Definition: FieldFieldFunctions.C:927
Foam::gAverage
Type gAverage(const FieldField< Field, Type > &f, const label comm)
The global arithmetic average of a FieldField.
Definition: FieldFieldFunctions.C:590
Foam::gMax
Type gMax(const FieldField< Field, Type > &f)
Definition: FieldFieldFunctions.C:577
Foam::gSumSqr
outerProduct1< Type >::type gSumSqr(const UList< Type > &f, const label comm)
Definition: FieldFunctions.C:605
Foam::gMinMaxMag
scalarMinMax gMinMaxMag(const FieldField< Field, Type > &f)
Definition: FieldFieldFunctions.C:581
f
labelList f(nPoints)
Foam::lerp
dimensioned< Type > lerp(const dimensioned< Type > &a, const dimensioned< Type > &b, const scalar t)
Foam::T
void T(FieldField< Field, Type > &f1, const FieldField< Field, Type > &f2)
Definition: FieldFieldFunctions.C:53
Foam::gSumMag
typeOfMag< Type >::type gSumMag(const FieldField< Field, Type > &f)
Definition: FieldFieldFunctions.C:583
fld
gmvFile<< "tracers "<< particles.size()<< nl;for(const passiveParticle &p :particles){ gmvFile<< p.position().x()<< ' ';}gmvFile<< nl;for(const passiveParticle &p :particles){ gmvFile<< p.position().y()<< ' ';}gmvFile<< nl;for(const passiveParticle &p :particles){ gmvFile<< p.position().z()<< ' ';}gmvFile<< nl;for(const word &name :lagrangianScalarNames){ IOField< scalar > fld(IOobject(name, runTime.timeName(), cloud::prefix, mesh, IOobject::MUST_READ, IOobject::NO_WRITE))
Definition: gmvOutputLagrangian.H:23
Foam::zero_one
Represents 0/1 range or concept. Used for tagged dispatch or clamping.
Definition: pTraits.H:51
Foam::powProduct::type
symmTypeOfRank< typename pTraits< arg1 >::cmptType, arg2 *direction(pTraits< arg1 >::rank) >::type type
Definition: products.H:176
Foam::sumMag
dimensioned< typename typeOfMag< Type >::type > sumMag(const DimensionedField< Type, GeoMesh > &f1, const label comm)
Definition: DimensionedFieldFunctions.C:302
Foam::pow
dimensionedScalar pow(const dimensionedScalar &ds, const dimensionedScalar &expt)
Definition: dimensionedScalar.C:68
UNARY_OPERATOR
#define UNARY_OPERATOR(ReturnType, Type1, Op, OpFunc, Dfunc)
Definition: DimensionedFieldFunctionsM.C:83
TERNARY_TYPE_FUNCTION_FFS
#define TERNARY_TYPE_FUNCTION_FFS(ReturnType, Type1, Type2, Type3, Func)
Definition: DimensionedFieldFunctionsM.C:910
Foam::cmptMin
void cmptMin(FieldField< Field, typename FieldField< Field, Type >::cmptType > &cf, const FieldField< Field, Type > &f)
Definition: FieldFieldFunctions.C:281
Foam::multiply
void multiply(DimensionedField< Type, GeoMesh > &result, const DimensionedField< Type, GeoMesh > &f1, const DimensionedField< scalar, GeoMesh > &f2)
TERNARY_FUNCTION
#define TERNARY_FUNCTION(ReturnType, Type1, Type2, Type3, Func)
Definition: DimensionedFieldFunctionsM.C:692
Foam::component
void component(FieldField< Field, typename FieldField< Field, Type >::cmptType > &sf, const FieldField< Field, Type > &f, const direction d)
Definition: FieldFieldFunctions.C:37
PRODUCT_OPERATOR
#define PRODUCT_OPERATOR(product, Op, OpFunc)
Definition: FieldFunctions.H:398
Foam::magSqr
dimensioned< typename typeOfMag< Type >::type > magSqr(const dimensioned< Type > &dt)
Foam
Namespace for OpenFOAM.
Definition: atmBoundaryLayer.C:26
Foam::clamp
dimensionSet clamp(const dimensionSet &a, const dimensionSet &range)
Definition: dimensionSet.C:271
Foam::typeOfMag::type
pTraits< typename pTraits< arg1 >::cmptType >::magType type
Definition: products.H:96
TMP_UNARY_FUNCTION
#define TMP_UNARY_FUNCTION(ReturnType, Func)
Definition: FieldFunctions.H:174