Loading...
Searching...
No Matches
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-------------------------------------------------------------------------------
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#define TEMPLATE template<class Type>
30#include "FieldFunctionsM.H"
31#include "UPstream.H"
32#include "MinMax.H"
33
34// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
35
36namespace Foam
37{
38
39// * * * * * * * * * * * * * * * Global Functions * * * * * * * * * * * * * //
40
41template<class Type>
42void component
43(
44 Field<typename Field<Type>::cmptType>& res,
45 const UList<Type>& f,
46 const direction d
47);
48
49
50template<class Type>
51void T(Field<Type>& res, const UList<Type>& f);
52
53
54template<class Type, direction r>
55void pow
56(
57 Field<typename powProduct<Type, r>::type>& res,
58 const UList<Type>& vf
59);
60
61
62template<class Type, direction r>
63tmp<Field<typename powProduct<Type, r>::type>>
64pow
65(
66 const UList<Type>& f,
67 typename powProduct<Type, r>::type
68 = pTraits<typename powProduct<Type, r>::type>::zero
69);
70
71template<class Type, direction r>
72tmp<Field<typename powProduct<Type, r>::type>>
73pow
74(
75 const tmp<Field<Type>>& tf,
76 typename powProduct<Type, r>::type
77 = pTraits<typename powProduct<Type, r>::type>::zero
78);
79
80
81template<class Type>
82void sqr
83(
84 Field<typename outerProduct<Type, Type>::type>& res,
85 const UList<Type>& vf
86);
87
88template<class Type>
89tmp<Field<typename outerProduct<Type, Type>::type>>
90sqr(const UList<Type>& f);
91
92template<class Type>
93tmp<Field<typename outerProduct<Type, Type>::type>>
94sqr(const tmp<Field<Type>>& tf);
95
96
97template<class Type>
98void magSqr
99(
100 Field<typename typeOfMag<Type>::type>& res,
101 const UList<Type>& f
102);
103
104template<class Type>
105tmp<Field<typename typeOfMag<Type>::type>>
106magSqr(const UList<Type>& f);
107
108template<class Type>
109tmp<Field<typename typeOfMag<Type>::type>>
110magSqr(const tmp<Field<Type>>& tf);
111
112
113template<class Type>
114void mag
115(
116 Field<typename typeOfMag<Type>::type>& res,
117 const UList<Type>& f
118);
119
120template<class Type>
121tmp<Field<typename typeOfMag<Type>::type>>
122mag(const UList<Type>& f);
123
124template<class Type>
125tmp<Field<typename typeOfMag<Type>::type>>
126mag(const tmp<Field<Type>>& tf);
127
128
129template<class Type>
130void cmptMax(Field<typename Field<Type>::cmptType>& res, const UList<Type>& f);
131
132template<class Type>
133tmp<Field<typename Field<Type>::cmptType>> cmptMax(const UList<Type>& f);
134
135template<class Type>
136tmp<Field<typename Field<Type>::cmptType>>
137cmptMax(const tmp<Field<Type>>& tf);
138
139
140template<class Type>
141void cmptMin(Field<typename Field<Type>::cmptType>& res, const UList<Type>& f);
142
143template<class Type>
144tmp<Field<typename Field<Type>::cmptType>> cmptMin(const UList<Type>& f);
145
146template<class Type>
147tmp<Field<typename Field<Type>::cmptType>>
148cmptMin(const tmp<Field<Type>>& tf);
149
150
151template<class Type>
152void cmptAv(Field<typename Field<Type>::cmptType>& res, const UList<Type>& f);
153
154template<class Type>
155tmp<Field<typename Field<Type>::cmptType>> cmptAv(const UList<Type>& f);
156
157template<class Type>
158tmp<Field<typename Field<Type>::cmptType>> cmptAv(const tmp<Field<Type>>& tf);
159
160
161template<class Type>
162void cmptMag(Field<Type>& res, const UList<Type>& f);
163
164template<class Type>
165tmp<Field<Type>> cmptMag(const UList<Type>& f);
166
167template<class Type>
168tmp<Field<Type>> cmptMag(const tmp<Field<Type>>& tf);
169
170
171template<class Type>
172void cmptMagSqr(Field<Type>& res, const UList<Type>& f);
173
174template<class Type>
175tmp<Field<Type>> cmptMagSqr(const UList<Type>& f);
176
177template<class Type>
178tmp<Field<Type>> cmptMagSqr(const tmp<Field<Type>>& tf);
179
180
181#define TMP_UNARY_FUNCTION(ReturnType, Func) \
182 \
183 \
184template<class Type> \
185ReturnType Func(const tmp<Field<Type>>& tf1);
186
187template<class Type>
188Type max(const UList<Type>& f);
189
190TMP_UNARY_FUNCTION(Type, max)
191
192template<class Type>
193Type min(const UList<Type>& f);
194
195TMP_UNARY_FUNCTION(Type, min)
196
197template<class Type>
198Type sum(const UList<Type>& f);
199
200TMP_UNARY_FUNCTION(Type, sum)
201
202
203// From MinMaxOps.H:
204// - Foam::minMax(const UList<Type>&)
205// - Foam::minMaxMag(const UList<Type>&)
206
207TMP_UNARY_FUNCTION(MinMax<Type>, minMax)
208TMP_UNARY_FUNCTION(scalarMinMax, minMaxMag)
209
210
211template<class Type>
212Type maxMagSqr(const UList<Type>& f);
213
214TMP_UNARY_FUNCTION(Type, maxMagSqr)
215
216template<class Type>
217Type minMagSqr(const UList<Type>& f);
218
219TMP_UNARY_FUNCTION(Type, minMagSqr)
220
221
222template<class Type>
223typename scalarProduct<Type, Type>::type
224sumProd
225(
226 const UList<Type>& f1,
227 const UList<Type>& f2
228);
229
230template<class Type>
231Type sumCmptProd(const UList<Type>& f1, const UList<Type>& f2);
232
233template<class Type>
234typename outerProduct1<Type>::type sumSqr(const UList<Type>& f);
235
236template<class Type>
237typename outerProduct1<Type>::type sumSqr(const tmp<Field<Type>>& tf);
238
239template<class Type>
240typename typeOfMag<Type>::type sumMag(const UList<Type>& f);
241
242TMP_UNARY_FUNCTION(typename typeOfMag<Type>::type, sumMag)
243
244template<class Type>
245Type sumCmptMag(const UList<Type>& f);
246
247TMP_UNARY_FUNCTION(Type, sumCmptMag)
248
249//- The local arithmetic average of a field
250template<class Type>
251Type average(const UList<Type>& f);
252
253TMP_UNARY_FUNCTION(Type, average)
254
255
256// With reduction on ReturnType
257#define G_UNARY_FUNCTION(ReturnType, gFunc, Func, rFunc) \
258 \
259template<class Type> \
260ReturnType gFunc(const UList<Type>& f, const label comm = UPstream::worldComm);\
261TMP_UNARY_FUNCTION(ReturnType, gFunc)
262
263G_UNARY_FUNCTION(Type, gMax, max, max)
264G_UNARY_FUNCTION(Type, gMin, min, min)
265G_UNARY_FUNCTION(Type, gSum, sum, sum)
266G_UNARY_FUNCTION(Type, gMaxMagSqr, maxMagSqr, maxMagSqr)
267G_UNARY_FUNCTION(Type, gMinMagSqr, minMagSqr, minMagSqr)
268G_UNARY_FUNCTION(Type, gSumCmptMag, sumCmptMag, sum)
269
270G_UNARY_FUNCTION(MinMax<Type>, gMinMax, minMax, sum)
271G_UNARY_FUNCTION(scalarMinMax, gMinMaxMag, minMaxMag, sum)
272
273G_UNARY_FUNCTION(typename outerProduct1<Type>::type, gSumSqr, sumSqr, sum)
274G_UNARY_FUNCTION(typename typeOfMag<Type>::type, gSumMag, sumMag, sum)
275
276#undef G_UNARY_FUNCTION
277
278
279template<class Type>
280typename scalarProduct<Type, Type>::type gSumProd
281(
282 const UList<Type>& f1,
283 const UList<Type>& f2,
284 const label comm = UPstream::worldComm
285);
286
287template<class Type>
288Type 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
296template<class Type>
297Type gAverage
298(
299 const UList<Type>& f,
301 const label comm = UPstream::worldComm
302);
303
304TMP_UNARY_FUNCTION(Type, gAverage)
305
306//- The global weighted average of a field,
307//- using the mag() of the weights.
308template<class Type>
309Type 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.
319template<class Type>
320Type 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.
332template<class Type>
333Type 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.
343template<class Type>
344Type 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
358BINARY_FUNCTION(Type, Type, Type, max)
359BINARY_FUNCTION(Type, Type, Type, min)
360BINARY_FUNCTION(Type, Type, Type, cmptMultiply)
361BINARY_FUNCTION(Type, Type, Type, cmptDivide)
362
363BINARY_TYPE_FUNCTION(Type, Type, Type, max)
364BINARY_TYPE_FUNCTION(Type, Type, Type, min)
365BINARY_TYPE_FUNCTION(Type, Type, Type, cmptMultiply)
366BINARY_TYPE_FUNCTION(Type, Type, Type, cmptDivide)
367
368BINARY_TYPE_FUNCTION_FS(Type, Type, MinMax<Type>, clamp)
369BINARY_TYPE_FUNCTION_FS(Type, Type, Foam::zero_one, clamp)
370
371// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
372
373TERNARY_FUNCTION(Type, Type, Type, scalar, lerp)
374TERNARY_TYPE_FUNCTION_FFS(Type, Type, Type, scalar, lerp)
375
376
377// * * * * * * * * * * * * * * * Global Operators * * * * * * * * * * * * * //
378
379UNARY_OPERATOR(Type, Type, -, negate)
380
381BINARY_OPERATOR(Type, Type, scalar, *, multiply)
382BINARY_OPERATOR(Type, scalar, Type, *, multiply)
383BINARY_OPERATOR(Type, Type, scalar, /, divide)
384
385BINARY_TYPE_OPERATOR_SF(Type, scalar, Type, *, multiply)
386BINARY_TYPE_OPERATOR_FS(Type, Type, scalar, *, multiply)
387
388BINARY_TYPE_OPERATOR_FS(Type, Type, scalar, /, divide)
389
390
391// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
392
393#define PRODUCT_OPERATOR(product, Op, OpFunc) \
394 \
395template<class Type1, class Type2> \
396void OpFunc \
397( \
398 Field<typename product<Type1, Type2>::type>& res, \
399 const UList<Type1>& f1, \
400 const UList<Type2>& f2 \
401); \
402 \
403template<class Type1, class Type2> \
404tmp<Field<typename product<Type1, Type2>::type>> \
405operator Op(const UList<Type1>& f1, const UList<Type2>& f2); \
406 \
407template<class Type1, class Type2> \
408tmp<Field<typename product<Type1, Type2>::type>> \
409operator Op(const UList<Type1>& f1, const tmp<Field<Type2>>& tf2); \
410 \
411template<class Type1, class Type2> \
412tmp<Field<typename product<Type1, Type2>::type>> \
413operator Op(const tmp<Field<Type1>>& tf1, const UList<Type2>& f2); \
414 \
415template<class Type1, class Type2> \
416tmp<Field<typename product<Type1, Type2>::type>> \
417operator Op(const tmp<Field<Type1>>& tf1, const tmp<Field<Type2>>& tf2); \
418 \
419template<class Type, class Form, class Cmpt, direction nCmpt> \
420void OpFunc \
421( \
422 Field<typename product<Type, Form>::type>& res, \
423 const UList<Type>& f1, \
424 const VectorSpace<Form,Cmpt,nCmpt>& vs \
425); \
426 \
427template<class Type, class Form, class Cmpt, direction nCmpt> \
428tmp<Field<typename product<Type, Form>::type>> \
429operator Op(const UList<Type>& f1, const VectorSpace<Form,Cmpt,nCmpt>& vs); \
430 \
431template<class Type, class Form, class Cmpt, direction nCmpt> \
432tmp<Field<typename product<Type, Form>::type>> \
433operator Op(const tmp<Field<Type>>&tf1,const VectorSpace<Form,Cmpt,nCmpt>&vs); \
434 \
435template<class Form, class Cmpt, direction nCmpt, class Type> \
436void OpFunc \
437( \
438 Field<typename product<Form, Type>::type>& res, \
439 const VectorSpace<Form,Cmpt,nCmpt>& vs, \
440 const UList<Type>& f1 \
441); \
442 \
443template<class Form, class Cmpt, direction nCmpt, class Type> \
444tmp<Field<typename product<Form, Type>::type>> \
445operator Op(const VectorSpace<Form,Cmpt,nCmpt>& vs, const UList<Type>& f1); \
446 \
447template<class Form, class Cmpt, direction nCmpt, class Type> \
448tmp<Field<typename product<Form, Type>::type>> \
449operator Op(const VectorSpace<Form,Cmpt,nCmpt>&vs,const tmp<Field<Type>>&tf1);
450
451PRODUCT_OPERATOR(typeOfSum, +, add)
452PRODUCT_OPERATOR(typeOfSum, -, subtract)
453
454PRODUCT_OPERATOR(outerProduct, *, outer)
455PRODUCT_OPERATOR(crossProduct, ^, cross)
456PRODUCT_OPERATOR(innerProduct, &, dot)
457PRODUCT_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// ************************************************************************* //
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
G_UNARY_FUNCTION
#define G_UNARY_FUNCTION(ReturnType, gFunc, Func, rFunc)
Definition FieldFieldFunctions.C:566
TMP_UNARY_FUNCTION
#define TMP_UNARY_FUNCTION(ReturnType, Func)
Definition FieldFieldFunctions.C:409
FieldFunctionsM.H
Macro functions for Field<Type> algebra.
fld
Info<< nl;Info<< "Write faMesh in vtk format:"<< nl;{ vtk::uindirectPatchWriter writer(aMesh.patch(), fileName(aMesh.time().globalPath()/vtkBaseFileName));writer.writeGeometry();globalIndex procAddr(aMesh.nFaces());labelList cellIDs;if(UPstream::master()) { cellIDs.resize(procAddr.totalSize());for(const labelRange &range :procAddr.ranges()) { auto slice=cellIDs.slice(range);slice=identity(range);} } writer.beginCellData(4);writer.writeProcIDs();writer.write("cellID", cellIDs);writer.write("area", aMesh.S().field());writer.write("normal", aMesh.faceAreaNormals());writer.beginPointData(1);writer.write("normal", aMesh.pointAreaNormals());Info<< " "<< writer.output().name()<< nl;}{ vtk::lineWriter writer(aMesh.points(), aMesh.edges(), fileName(aMesh.time().globalPath()/(vtkBaseFileName+"-edges")));writer.writeGeometry();writer.beginCellData(4);writer.writeProcIDs();{ Field< scalar > fld(faMeshTools::flattenEdgeField(aMesh.magLe(), true))
Foam::Field::cmptType
pTraits< Type >::cmptType cmptType
Component type.
Definition Field.H:178
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 UList.H:89
Foam::UPstream::worldComm
static label worldComm
Communicator for all ranks. May differ from commGlobal() if local worlds are in use.
Definition UPstream.H:1069
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::scalarProduct::type
pTraits< arg1 >::cmptType type
Definition products.H:163
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
T
const volScalarField & T
Definition createFieldRefs.H:2
PRODUCT_OPERATOR
#define PRODUCT_OPERATOR(product, op, opFunc)
Definition dimensionedType.C:888
Foam
Namespace for OpenFOAM.
Definition atmBoundaryLayer.C:27
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::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::gSumProd
scalarProduct< Type, Type >::type gSumProd(const UList< Type > &f1, const UList< Type > &f2, const label comm)
Definition FieldFunctions.C:613
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::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::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::component
void component(FieldField< Field, typename FieldField< Field, Type >::cmptType > &sf, const FieldField< Field, Type > &f, const direction d)
Definition FieldFieldFunctions.C:37
Foam::sumCmptMag
Type sumCmptMag(const UList< Type > &f1)
Definition FieldFunctions.C:552
Foam::cmptMin
void cmptMin(FieldField< Field, typename FieldField< Field, Type >::cmptType > &cf, const FieldField< Field, Type > &f)
Definition FieldFieldFunctions.C:281
Foam::cmptDivide
dimensioned< Type > cmptDivide(const dimensioned< Type > &, const dimensioned< Type > &)
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
Foam::sumCmptProd
Type sumCmptProd(const UList< Type > &f1, const UList< Type > &f2)
Definition FieldFunctions.C:488
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::minMagSqr
Type minMagSqr(const UList< Type > &f1)
Definition FieldFunctions.C:448
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::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::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::gMaxMagSqr
Type gMaxMagSqr(const UList< Type > &f, const label comm)
Definition FieldFunctions.C:598
Foam::minMax
MinMax< label > minMax(const labelHashSet &set)
Find the min/max values of labelHashSet.
Definition hashSets.C:54
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::sumSqr
outerProduct1< Type >::type sumSqr(const UList< Type > &f1)
Definition FieldFunctions.C:511
Foam::sumProd
complex sumProd(const UList< complex > &f1, const UList< complex > &f2)
Sum product.
Definition complexField.C:245
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::cmptMagSqr
void cmptMagSqr(Field< Type > &result, const UList< Type > &f1)
Definition FieldFunctions.C:332
Foam::direction
uint8_t direction
Definition direction.H:49
Foam::cmptMax
void cmptMax(FieldField< Field, typename FieldField< Field, Type >::cmptType > &cf, const FieldField< Field, Type > &f)
Definition FieldFieldFunctions.C:236
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::cmptMag
void cmptMag(FieldField< Field, Type > &cf, const FieldField< Field, Type > &f)
Definition FieldFieldFunctions.C:371
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::gSumSqr
outerProduct1< Type >::type gSumSqr(const UList< Type > &f, const label comm)
Definition FieldFunctions.C:605
Foam::negate
void negate(DimensionedField< Type, GeoMesh > &result, const DimensionedField< Type, GeoMesh > &f1)
Definition DimensionedFieldFunctions.C:393
Foam::gMinMagSqr
Type gMinMagSqr(const UList< Type > &f, const label comm)
Definition FieldFunctions.C:599
Foam::maxMagSqr
Type maxMagSqr(const UList< Type > &f1)
Definition FieldFunctions.C:423
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::gSumCmptMag
Type gSumCmptMag(const UList< Type > &f, const label comm)
Definition FieldFunctions.C:600
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::gSumCmptProd
Type gSumCmptProd(const UList< Type > &f1, const UList< Type > &f2, const label comm)
Definition FieldFunctions.C:628
Foam::sumMag
dimensioned< typename typeOfMag< Type >::type > sumMag(const DimensionedField< Type, GeoMesh > &f1, const label comm)
Definition DimensionedFieldFunctions.C:302
f
labelList f(nPoints)
add
dict add("bounds", meshBb)