FieldFunctions.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-2026 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 "SubField.H"
27 #include "PstreamReduceOps.H"
28 #include "FieldReuseFunctions.H"
29 
30 #define TEMPLATE template<class Type>
31 #include "FieldFunctionsM.C"
32 
33 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
34 
35 namespace Foam
36 {
37 
38 /* * * * * * * * * * * * * * * * Global Functions * * * * * * * * * * * * * */
39 
40 template<class Type>
41 void component
42 (
43  Field<typename Field<Type>::cmptType>& res,
44  const UList<Type>& f,
45  const direction d
46 )
47 {
48  typedef typename Field<Type>::cmptType cmptType;
49  TFOR_ALL_F_OP_F_FUNC_S
50  (
51  cmptType, res, =, Type, f, .component, const direction, d
52  )
53 }
54 
55 
56 template<class Type>
57 void T(Field<Type>& res, const UList<Type>& f)
58 {
59  TFOR_ALL_F_OP_F_FUNC(Type, res, =, Type, f, T)
60 }
61 
62 
63 template<class Type, direction r>
64 void pow
65 (
66  Field<typename powProduct<Type, r>::type>& res,
67  const Field<Type>& vf
68 )
69 {
70  typedef typename powProduct<Type, r>::type powProductType;
71  TFOR_ALL_F_OP_FUNC_F_S
72  (
73  powProductType, res, =, pow, Type, vf, powProductType,
74  pTraits<powProductType>::zero
75  )
76 }
77 
78 template<class Type, direction r>
79 void pow
80 (
81  Field<typename powProduct<Type, r>::type>& res,
82  const SubField<Type>& vf
83 )
84 {
85  typedef typename powProduct<Type, r>::type powProductType;
86  TFOR_ALL_F_OP_FUNC_F_S
87  (
88  powProductType, res, =, pow, Type, vf, powProductType,
89  pTraits<powProductType>::zero
90  )
91 }
92 
93 
94 template<class Type, direction r>
95 tmp<Field<typename powProduct<Type, r>::type>>
96 pow
97 (
98  const Field<Type>& f,
99  typename powProduct<Type, r>::type
100 )
101 {
102  typedef typename powProduct<Type, r>::type powProductType;
103  tmp<Field<powProductType>> tRes
104  (
105  new Field<powProductType>(f.size())
106  );
107  pow<Type, r>(tRes.ref(), f);
108  return tRes;
109 }
110 
111 template<class Type, direction r>
112 tmp<Field<typename powProduct<Type, r>::type>>
113 pow
114 (
115  const SubField<Type>& f,
116  typename powProduct<Type, r>::type
117 )
118 {
119  typedef typename powProduct<Type, r>::type powProductType;
120  tmp<Field<powProductType>> tRes
121  (
122  new Field<powProductType>(f.size())
123  );
124  pow<Type, r>(tRes.ref(), f);
125  return tRes;
126 }
127 
128 template<class Type, direction r>
129 tmp<Field<typename powProduct<Type, r>::type>>
130 pow
131 (
132  const tmp<Field<Type>>& tf,
133  typename powProduct<Type, r>::type
134 )
135 {
136  typedef typename powProduct<Type, r>::type powProductType;
137  tmp<Field<powProductType>> tRes = reuseTmp<powProductType, Type>::New(tf);
138  pow<Type, r>(tRes.ref(), tf());
139  tf.clear();
140  return tRes;
141 }
142 
143 
144 template<class Type>
145 void sqr
146 (
147  Field<typename outerProduct<Type, Type>::type>& res,
148  const UList<Type>& vf
149 )
150 {
151  typedef typename outerProduct<Type, Type>::type outerProductType;
152  TFOR_ALL_F_OP_FUNC_F(outerProductType, res, =, sqr, Type, vf)
153 }
154 
155 template<class Type>
156 tmp<Field<typename outerProduct<Type, Type>::type>>
157 sqr(const Field<Type>& f)
158 {
159  typedef typename outerProduct<Type, Type>::type outerProductType;
160  tmp<Field<outerProductType>> tRes
161  (
162  new Field<outerProductType>(f.size())
163  );
164  sqr(tRes.ref(), f);
165  return tRes;
166 }
167 
168 template<class Type>
169 tmp<Field<typename outerProduct<Type, Type>::type>>
170 sqr(const SubField<Type>& f)
171 {
172  typedef typename outerProduct<Type, Type>::type outerProductType;
173  tmp<Field<outerProductType>> tRes
174  (
175  new Field<outerProductType>(f.size())
176  );
177  sqr(tRes.ref(), f);
178  return tRes;
179 }
180 
181 template<class Type>
182 tmp<Field<typename outerProduct<Type, Type>::type>>
183 sqr(const tmp<Field<Type>>& tf)
184 {
185  typedef typename outerProduct<Type, Type>::type outerProductType;
186  tmp<Field<outerProductType>> tRes =
187  reuseTmp<outerProductType, Type>::New(tf);
188  sqr(tRes.ref(), tf());
189  tf.clear();
190  return tRes;
191 }
192 
193 
194 template<class Type>
195 void magSqr(Field<scalar>& res, const UList<Type>& f)
196 {
197  TFOR_ALL_F_OP_FUNC_F(scalar, res, =, magSqr, Type, f)
198 }
199 
200 template<class Type>
201 tmp<Field<scalar>> magSqr(const Field<Type>& f)
202 {
203  tmp<Field<scalar>> tRes(new Field<scalar>(f.size()));
204  magSqr(tRes.ref(), f);
205  return tRes;
206 }
207 
208 template<class Type>
209 tmp<Field<scalar>> magSqr(const SubField<Type>& f)
210 {
211  tmp<Field<scalar>> tRes(new Field<scalar>(f.size()));
212  magSqr(tRes.ref(), f);
213  return tRes;
214 }
215 
216 template<class Type>
217 tmp<Field<scalar>> magSqr(const tmp<Field<Type>>& tf)
218 {
219  tmp<Field<scalar>> tRes = reuseTmp<scalar, Type>::New(tf);
220  magSqr(tRes.ref(), tf());
221  tf.clear();
222  return tRes;
223 }
224 
225 
226 template<class Type>
227 void mag(Field<scalar>& res, const UList<Type>& f)
228 {
229  TFOR_ALL_F_OP_FUNC_F(scalar, res, =, mag, Type, f)
230 }
231 
232 template<class Type>
233 tmp<Field<scalar>> mag(const Field<Type>& f)
234 {
235  tmp<Field<scalar>> tRes(new Field<scalar>(f.size()));
236  mag(tRes.ref(), f);
237  return tRes;
238 }
239 
240 template<class Type>
241 tmp<Field<scalar>> mag(const SubField<Type>& f)
242 {
243  tmp<Field<scalar>> tRes(new Field<scalar>(f.size()));
244  mag(tRes.ref(), f);
245  return tRes;
246 }
247 
248 template<class Type>
249 tmp<Field<scalar>> mag(const tmp<Field<Type>>& tf)
250 {
251  tmp<Field<scalar>> tRes = reuseTmp<scalar, Type>::New(tf);
252  mag(tRes.ref(), tf());
253  tf.clear();
254  return tRes;
255 }
256 
257 
258 template<class Type>
259 void cmptMax(Field<typename Field<Type>::cmptType>& res, const UList<Type>& f)
260 {
261  typedef typename Field<Type>::cmptType cmptType;
262  TFOR_ALL_F_OP_FUNC_F(cmptType, res, =, cmptMax, Type, f)
263 }
264 
265 template<class Type>
266 tmp<Field<typename Field<Type>::cmptType>> cmptMax(const Field<Type>& f)
267 {
268  typedef typename Field<Type>::cmptType cmptType;
269  tmp<Field<cmptType>> tRes(new Field<cmptType>(f.size()));
270  cmptMax(tRes.ref(), f);
271  return tRes;
272 }
273 
274 template<class Type>
275 tmp<Field<typename Field<Type>::cmptType>> cmptMax(const SubField<Type>& f)
276 {
277  typedef typename Field<Type>::cmptType cmptType;
278  tmp<Field<cmptType>> tRes(new Field<cmptType>(f.size()));
279  cmptMax(tRes.ref(), f);
280  return tRes;
281 }
282 
283 template<class Type>
284 tmp<Field<typename Field<Type>::cmptType>> cmptMax(const tmp<Field<Type>>& tf)
285 {
286  typedef typename Field<Type>::cmptType cmptType;
287  tmp<Field<cmptType>> tRes = reuseTmp<cmptType, Type>::New(tf);
288  cmptMax(tRes.ref(), tf());
289  tf.clear();
290  return tRes;
291 }
292 
293 
294 template<class Type>
295 void cmptMin(Field<typename Field<Type>::cmptType>& res, const UList<Type>& f)
296 {
297  typedef typename Field<Type>::cmptType cmptType;
298  TFOR_ALL_F_OP_FUNC_F(cmptType, res, =, cmptMin, Type, f)
299 }
300 
301 template<class Type>
302 tmp<Field<typename Field<Type>::cmptType>> cmptMin(const Field<Type>& f)
303 {
304  typedef typename Field<Type>::cmptType cmptType;
305  tmp<Field<cmptType>> tRes(new Field<cmptType>(f.size()));
306  cmptMin(tRes.ref(), f);
307  return tRes;
308 }
309 
310 template<class Type>
311 tmp<Field<typename Field<Type>::cmptType>> cmptMin(const SubField<Type>& f)
312 {
313  typedef typename Field<Type>::cmptType cmptType;
314  tmp<Field<cmptType>> tRes(new Field<cmptType>(f.size()));
315  cmptMin(tRes.ref(), f);
316  return tRes;
317 }
318 
319 template<class Type>
320 tmp<Field<typename Field<Type>::cmptType>> cmptMin(const tmp<Field<Type>>& tf)
321 {
322  typedef typename Field<Type>::cmptType cmptType;
323  tmp<Field<cmptType>> tRes = reuseTmp<cmptType, Type>::New(tf);
324  cmptMin(tRes.ref(), tf());
325  tf.clear();
326  return tRes;
327 }
328 
329 
330 template<class Type>
331 void cmptAv(Field<typename Field<Type>::cmptType>& res, const UList<Type>& f)
332 {
333  typedef typename Field<Type>::cmptType cmptType;
334  TFOR_ALL_F_OP_FUNC_F(cmptType, res, =, cmptAv, Type, f)
335 }
336 
337 template<class Type>
338 tmp<Field<typename Field<Type>::cmptType>> cmptAv(const Field<Type>& f)
339 {
340  typedef typename Field<Type>::cmptType cmptType;
341  tmp<Field<cmptType>> tRes(new Field<cmptType>(f.size()));
342  cmptAv(tRes.ref(), f);
343  return tRes;
344 }
345 
346 template<class Type>
347 tmp<Field<typename Field<Type>::cmptType>> cmptAv(const SubField<Type>& f)
348 {
349  typedef typename Field<Type>::cmptType cmptType;
350  tmp<Field<cmptType>> tRes(new Field<cmptType>(f.size()));
351  cmptAv(tRes.ref(), f);
352  return tRes;
353 }
354 
355 template<class Type>
356 tmp<Field<typename Field<Type>::cmptType>> cmptAv(const tmp<Field<Type>>& tf)
357 {
358  typedef typename Field<Type>::cmptType cmptType;
359  tmp<Field<cmptType>> tRes = reuseTmp<cmptType, Type>::New(tf);
360  cmptAv(tRes.ref(), tf());
361  tf.clear();
362  return tRes;
363 }
364 
365 
366 template<class Type>
367 void cmptMag(Field<Type>& res, const UList<Type>& f)
368 {
369  TFOR_ALL_F_OP_FUNC_F(Type, res, =, cmptMag, Type, f)
370 }
371 
372 template<class Type>
373 tmp<Field<Type>> cmptMag(const Field<Type>& f)
374 {
375  tmp<Field<Type>> tRes(new Field<Type>(f.size()));
376  cmptMag(tRes.ref(), f);
377  return tRes;
378 }
379 
380 template<class Type>
381 tmp<Field<Type>> cmptMag(const SubField<Type>& f)
382 {
383  tmp<Field<Type>> tRes(new Field<Type>(f.size()));
384  cmptMag(tRes.ref(), f);
385  return tRes;
386 }
387 
388 template<class Type>
389 tmp<Field<Type>> cmptMag(const tmp<Field<Type>>& tf)
390 {
391  tmp<Field<Type>> tRes = New(tf);
392  cmptMag(tRes.ref(), tf());
393  tf.clear();
394  return tRes;
395 }
396 
397 
398 BINARY_FUNCTION(Type, Type, Type, max)
399 BINARY_FUNCTION(Type, Type, Type, min)
400 BINARY_FUNCTION(Type, Type, Type, cmptMultiply)
401 BINARY_FUNCTION(Type, Type, Type, cmptDivide)
402 
403 BINARY_TYPE_FUNCTION(Type, Type, Type, max)
404 BINARY_TYPE_FUNCTION(Type, Type, Type, min)
405 BINARY_TYPE_FUNCTION(Type, Type, Type, cmptMultiply)
406 BINARY_TYPE_FUNCTION(Type, Type, Type, cmptDivide)
407 
408 
409 /* * * * * * * * * * * * * * * * Global operators * * * * * * * * * * * * * */
410 
411 UNARY_OPERATOR(Type, Type, -, negate)
412 
413 BINARY_OPERATOR(Type, Type, scalar, *, multiply)
414 BINARY_OPERATOR(Type, scalar, Type, *, multiply)
415 BINARY_OPERATOR(Type, Type, scalar, /, divide)
416 
417 BINARY_TYPE_OPERATOR_SF(Type, scalar, Type, *, multiply)
418 BINARY_TYPE_OPERATOR_FS(Type, Type, scalar, *, multiply)
419 
420 BINARY_TYPE_OPERATOR_FS(Type, Type, scalar, /, divide)
421 
422 
423 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
424 
425 #define PRODUCT_OPERATOR(product, Op, OpFunc) \
426  \
427 template<class Type1, class Type2> \
428 void OpFunc \
429 ( \
430  Field<typename product<Type1, Type2>::type>& res, \
431  const UList<Type1>& f1, \
432  const UList<Type2>& f2 \
433 ) \
434 { \
435  typedef typename product<Type1, Type2>::type productType; \
436  TFOR_ALL_F_OP_F_OP_F(productType, res, =, Type1, f1, Op, Type2, f2) \
437 } \
438  \
439 template<class Type1, class Type2> \
440 tmp<Field<typename product<Type1, Type2>::type>> \
441 operator Op(const Field<Type1>& f1, const Field<Type2>& f2) \
442 { \
443  typedef typename product<Type1, Type2>::type productType; \
444  tmp<Field<productType>> tRes(new Field<productType>(f1.size())); \
445  OpFunc(tRes.ref(), f1, f2); \
446  return tRes; \
447 } \
448  \
449 template<class Type1, class Type2> \
450 tmp<Field<typename product<Type1, Type2>::type>> \
451 operator Op(const Field<Type1>& f1, const SubField<Type2>& f2) \
452 { \
453  typedef typename product<Type1, Type2>::type productType; \
454  tmp<Field<productType>> tRes(new Field<productType>(f1.size())); \
455  OpFunc(tRes.ref(), f1, f2); \
456  return tRes; \
457 } \
458  \
459 template<class Type1, class Type2> \
460 tmp<Field<typename product<Type1, Type2>::type>> \
461 operator Op(const SubField<Type1>& f1, const Field<Type2>& f2) \
462 { \
463  typedef typename product<Type1, Type2>::type productType; \
464  tmp<Field<productType>> tRes(new Field<productType>(f1.size())); \
465  OpFunc(tRes.ref(), f1, f2); \
466  return tRes; \
467 } \
468  \
469 template<class Type1, class Type2> \
470 tmp<Field<typename product<Type1, Type2>::type>> \
471 operator Op(const SubField<Type1>& f1, const SubField<Type2>& f2) \
472 { \
473  typedef typename product<Type1, Type2>::type productType; \
474  tmp<Field<productType>> tRes(new Field<productType>(f1.size())); \
475  OpFunc(tRes.ref(), f1, f2); \
476  return tRes; \
477 } \
478  \
479 template<class Type1, class Type2> \
480 tmp<Field<typename product<Type1, Type2>::type>> \
481 operator Op(const Field<Type1>& f1, const tmp<Field<Type2>>& tf2) \
482 { \
483  typedef typename product<Type1, Type2>::type productType; \
484  tmp<Field<productType>> tRes = reuseTmp<productType, Type2>::New(tf2); \
485  OpFunc(tRes.ref(), f1, tf2()); \
486  tf2.clear(); \
487  return tRes; \
488 } \
489  \
490 template<class Type1, class Type2> \
491 tmp<Field<typename product<Type1, Type2>::type>> \
492 operator Op(const SubField<Type1>& f1, const tmp<Field<Type2>>& tf2) \
493 { \
494  typedef typename product<Type1, Type2>::type productType; \
495  tmp<Field<productType>> tRes = reuseTmp<productType, Type2>::New(tf2); \
496  OpFunc(tRes.ref(), f1, tf2()); \
497  tf2.clear(); \
498  return tRes; \
499 } \
500  \
501 template<class Type1, class Type2> \
502 tmp<Field<typename product<Type1, Type2>::type>> \
503 operator Op(const tmp<Field<Type1>>& tf1, const Field<Type2>& f2) \
504 { \
505  typedef typename product<Type1, Type2>::type productType; \
506  tmp<Field<productType>> tRes = reuseTmp<productType, Type1>::New(tf1); \
507  OpFunc(tRes.ref(), tf1(), f2); \
508  tf1.clear(); \
509  return tRes; \
510 } \
511  \
512 template<class Type1, class Type2> \
513 tmp<Field<typename product<Type1, Type2>::type>> \
514 operator Op(const tmp<Field<Type1>>& tf1, const SubField<Type2>& f2) \
515 { \
516  typedef typename product<Type1, Type2>::type productType; \
517  tmp<Field<productType>> tRes = reuseTmp<productType, Type1>::New(tf1); \
518  OpFunc(tRes.ref(), tf1(), f2); \
519  tf1.clear(); \
520  return tRes; \
521 } \
522  \
523 template<class Type1, class Type2> \
524 tmp<Field<typename product<Type1, Type2>::type>> \
525 operator Op(const tmp<Field<Type1>>& tf1, const tmp<Field<Type2>>& tf2) \
526 { \
527  typedef typename product<Type1, Type2>::type productType; \
528  tmp<Field<productType>> tRes = \
529  reuseTmpTmp<productType, Type1, Type1, Type2>::New(tf1, tf2); \
530  OpFunc(tRes.ref(), tf1(), tf2()); \
531  tf1.clear(); \
532  tf2.clear(); \
533  return tRes; \
534 } \
535  \
536 template<class Type, class Form, class Cmpt, direction nCmpt> \
537 void OpFunc \
538 ( \
539  Field<typename product<Type, Form>::type>& res, \
540  const UList<Type>& f1, \
541  const VectorSpace<Form,Cmpt,nCmpt>& vs \
542 ) \
543 { \
544  typedef typename product<Type, Form>::type productType; \
545  TFOR_ALL_F_OP_F_OP_S \
546  (productType, res, =,Type, f1, Op, Form, static_cast<const Form&>(vs)) \
547 } \
548  \
549 template<class Type, class Form, class Cmpt, direction nCmpt> \
550 tmp<Field<typename product<Type, Form>::type>> \
551 operator Op(const Field<Type>& f1, const VectorSpace<Form,Cmpt,nCmpt>& vs) \
552 { \
553  typedef typename product<Type, Form>::type productType; \
554  tmp<Field<productType>> tRes(new Field<productType>(f1.size())); \
555  OpFunc(tRes.ref(), f1, static_cast<const Form&>(vs)); \
556  return tRes; \
557 } \
558  \
559 template<class Type, class Form, class Cmpt, direction nCmpt> \
560 tmp<Field<typename product<Type, Form>::type>> \
561 operator Op(const SubField<Type>& f1, const VectorSpace<Form,Cmpt,nCmpt>& vs) \
562 { \
563  typedef typename product<Type, Form>::type productType; \
564  tmp<Field<productType>> tRes(new Field<productType>(f1.size())); \
565  OpFunc(tRes.ref(), f1, static_cast<const Form&>(vs)); \
566  return tRes; \
567 } \
568  \
569 template<class Type, class Form, class Cmpt, direction nCmpt> \
570 tmp<Field<typename product<Type, Form>::type>> \
571 operator Op \
572 ( \
573  const tmp<Field<Type>>& tf1, \
574  const VectorSpace<Form,Cmpt,nCmpt>& vs \
575 ) \
576 { \
577  typedef typename product<Type, Form>::type productType; \
578  tmp<Field<productType>> tRes = reuseTmp<productType, Type>::New(tf1); \
579  OpFunc(tRes.ref(), tf1(), static_cast<const Form&>(vs)); \
580  tf1.clear(); \
581  return tRes; \
582 } \
583  \
584 template<class Form, class Cmpt, direction nCmpt, class Type> \
585 void OpFunc \
586 ( \
587  Field<typename product<Form, Type>::type>& res, \
588  const VectorSpace<Form,Cmpt,nCmpt>& vs, \
589  const UList<Type>& f1 \
590 ) \
591 { \
592  typedef typename product<Form, Type>::type productType; \
593  TFOR_ALL_F_OP_S_OP_F \
594  (productType, res, =,Form,static_cast<const Form&>(vs), Op, Type, f1) \
595 } \
596  \
597 template<class Form, class Cmpt, direction nCmpt, class Type> \
598 tmp<Field<typename product<Form, Type>::type>> \
599 operator Op(const VectorSpace<Form,Cmpt,nCmpt>& vs, const Field<Type>& f1) \
600 { \
601  typedef typename product<Form, Type>::type productType; \
602  tmp<Field<productType>> tRes(new Field<productType>(f1.size())); \
603  OpFunc(tRes.ref(), static_cast<const Form&>(vs), f1); \
604  return tRes; \
605 } \
606  \
607 template<class Form, class Cmpt, direction nCmpt, class Type> \
608 tmp<Field<typename product<Form, Type>::type>> \
609 operator Op(const VectorSpace<Form,Cmpt,nCmpt>& vs, const SubField<Type>& f1) \
610 { \
611  typedef typename product<Form, Type>::type productType; \
612  tmp<Field<productType>> tRes(new Field<productType>(f1.size())); \
613  OpFunc(tRes.ref(), static_cast<const Form&>(vs), f1); \
614  return tRes; \
615 } \
616  \
617 template<class Form, class Cmpt, direction nCmpt, class Type> \
618 tmp<Field<typename product<Form, Type>::type>> \
619 operator Op \
620 ( \
621  const VectorSpace<Form,Cmpt,nCmpt>& vs, const tmp<Field<Type>>& tf1 \
622 ) \
623 { \
624  typedef typename product<Form, Type>::type productType; \
625  tmp<Field<productType>> tRes = reuseTmp<productType, Type>::New(tf1); \
626  OpFunc(tRes.ref(), static_cast<const Form&>(vs), tf1()); \
627  tf1.clear(); \
628  return tRes; \
629 }
630 
631 PRODUCT_OPERATOR(typeOfSum, +, add)
632 PRODUCT_OPERATOR(typeOfSum, -, subtract)
633 
634 PRODUCT_OPERATOR(outerProduct, *, outer)
635 PRODUCT_OPERATOR(crossProduct, ^, cross)
636 PRODUCT_OPERATOR(innerProduct, &, dot)
637 PRODUCT_OPERATOR(scalarProduct, &&, dotdot)
638 
639 #undef PRODUCT_OPERATOR
640 
641 
642 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
643 
644 } // End namespace Foam
645 
646 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
647 
648 #include "undefFieldFunctionsM.H"
649 
650 // ************************************************************************* //
BINARY_FUNCTION
#define BINARY_FUNCTION(ReturnType, Type1, Type2, Func)
Definition: DimensionedFieldFunctionsM.C:144
UNARY_OPERATOR
#define UNARY_OPERATOR(ReturnType, Type1, Op, OpFunc, Dfunc)
Definition: DimensionedFieldFunctionsM.C:87
BINARY_OPERATOR
#define BINARY_OPERATOR(ReturnType, Type1, Type2, Op, OpName, OpFunc)
Definition: DimensionedFieldFunctionsM.C:455
BINARY_TYPE_OPERATOR_SF
#define BINARY_TYPE_OPERATOR_SF(ReturnType, Type1, Type2, Op, OpName, OpFunc)
Definition: DimensionedFieldFunctionsM.C:603
BINARY_TYPE_OPERATOR_FS
#define BINARY_TYPE_OPERATOR_FS(ReturnType, Type1, Type2, Op, OpName, OpFunc)
Definition: DimensionedFieldFunctionsM.C:691
BINARY_TYPE_FUNCTION
#define BINARY_TYPE_FUNCTION(ReturnType, Type1, Type2, Func)
Definition: DimensionedFieldFunctionsM.C:448
PRODUCT_OPERATOR
#define PRODUCT_OPERATOR(product, Op, OpFunc)
Definition: FieldFunctions.C:425
TFOR_ALL_F_OP_FUNC_F_S
#define TFOR_ALL_F_OP_FUNC_F_S(typeF1, f1, OP, FUNC, typeF2, f2, typeS, s)
Definition: FieldM.H:180
TFOR_ALL_F_OP_F_FUNC
#define TFOR_ALL_F_OP_F_FUNC(typeF1, f1, OP, typeF2, f2, FUNC)
Definition: FieldM.H:127
TFOR_ALL_F_OP_F_FUNC_S
#define TFOR_ALL_F_OP_F_FUNC_S(typeF1, f1, OP, typeF2, f2, FUNC, typeS, s)
Definition: FieldM.H:240
TFOR_ALL_F_OP_FUNC_F
#define TFOR_ALL_F_OP_FUNC_F(typeF1, f1, OP, FUNC, typeF2, f2)
Definition: FieldM.H:112
PstreamReduceOps.H
Inter-processor communication reduction functions.
Foam::Field
Pre-declare SubField and related Field type.
Definition: Field.H:83
Foam::Field::cmptType
pTraits< Type >::cmptType cmptType
Component type.
Definition: Field.H:98
Foam::List::size
void size(const label)
Override size to be inconsistent with allocated storage.
Definition: ListI.H:164
Foam::List::clear
void clear()
Clear the list, i.e. set size to zero.
Definition: ListI.H:125
Foam::SubField
Pre-declare related SubField type.
Definition: SubField.H:63
Foam::outerProduct::type
typeOfRank< typename pTraits< arg1 >::cmptType, direction(pTraits< arg1 >::rank)+direction(pTraits< arg2 >::rank) >::type type
Definition: products.H:90
Foam::pTraits
Traits class for primitives.
Definition: pTraits.H:53
Foam::powProduct::type
symmTypeOfRank< typename pTraits< arg1 >::cmptType, arg2 *direction(pTraits< arg1 >::rank) >::type type
Definition: products.H:136
Foam::reuseTmp::New
static tmp< Field< TypeR > > New(const tmp< Field< Type1 >> &tf1)
Definition: FieldReuseFunctions.H:66
Foam::tmp
A class for managing temporary objects.
Definition: tmp.H:55
Foam::tmp::ref
T & ref() const
Return non-const reference or generate a fatal error.
Definition: tmpI.H:197
tf
const tensorField & tf
Definition: getPatchFieldTensor.H:36
Foam
Namespace for OpenFOAM.
Definition: atmosphericBoundaryLayer.C:32
Foam::subtract
void subtract(GeometricField< typename typeOfSum< Type1, Type2 >::type, GeoMesh, PrimitiveField1 > &gf, const GeometricField< Type1, GeoMesh, PrimitiveField2 > &gf1, const GeometricField< Type2, GeoMesh, PrimitiveField3 > &gf2)
Definition: GeometricFieldFunctions.C:1002
Foam::outer
void outer(GeometricField< typename outerProduct< Type1, Type2 >::type, GeoMesh, PrimitiveField1 > &gf, const GeometricField< Type1, GeoMesh, PrimitiveField2 > &gf1, const GeometricField< Type2, GeoMesh, PrimitiveField3 > &gf2)
Definition: GeometricFieldFunctions.C:1004
Foam::add
void add(GeometricField< typename typeOfSum< Type1, Type2 >::type, GeoMesh, PrimitiveField1 > &gf, const GeometricField< Type1, GeoMesh, PrimitiveField2 > &gf1, const GeometricField< Type2, GeoMesh, PrimitiveField3 > &gf2)
Definition: GeometricFieldFunctions.C:1001
Foam::cmptMultiply
tmp< DimensionedField< Type, GeoMesh, Field > > cmptMultiply(const DimensionedField< Type, GeoMesh, PrimitiveField1 > &df1, const DimensionedField< Type, GeoMesh, PrimitiveField2 > &df2)
Foam::divide
void divide(pointPatchField< Type > &f, const pointPatchField< Type > &f1, const pointPatchField< scalar > &f2)
Definition: pointPatchFieldFunctions.H:157
Foam::cmptMax
void cmptMax(Field< typename Field< Type >::cmptType > &res, const UList< Type > &f)
Definition: FieldFunctions.C:259
Foam::sqr
tmp< DimensionedField< typename outerProduct< Type, Type >::type, GeoMesh, Field >> sqr(const DimensionedField< Type, GeoMesh, PrimitiveField > &df)
Definition: DimensionedFieldFunctions.C:134
Foam::component
void component(GeometricField< typename GeometricField< Type, GeoMesh, PrimitiveField1 >::cmptType, GeoMesh, PrimitiveField1 > &gcf, const GeometricField< Type, GeoMesh, PrimitiveField2 > &gf, const direction d)
Definition: GeometricFieldFunctions.C:63
Foam::cmptDivide
tmp< DimensionedField< Type, GeoMesh, Field > > cmptDivide(const DimensionedField< Type, GeoMesh, PrimitiveField1 > &df1, const DimensionedField< Type, GeoMesh, PrimitiveField2 > &df2)
Foam::dotdot
void dotdot(GeometricField< typename scalarProduct< Type1, Type2 >::type, GeoMesh, PrimitiveField1 > &gf, const GeometricField< Type1, GeoMesh, PrimitiveField2 > &gf1, const GeometricField< Type2, GeoMesh, PrimitiveField3 > &gf2)
Definition: GeometricFieldFunctions.C:1007
Foam::min
dimensioned< Type > min(const DimensionedField< Type, GeoMesh, PrimitiveField > &df)
Definition: DimensionedFieldFunctions.C:374
Foam::cmptMin
void cmptMin(Field< typename Field< Type >::cmptType > &res, const UList< Type > &f)
Definition: FieldFunctions.C:295
Foam::cross
void cross(GeometricField< typename crossProduct< Type1, Type2 >::type, GeoMesh, PrimitiveField1 > &gf, const GeometricField< Type1, GeoMesh, PrimitiveField2 > &gf1, const GeometricField< Type2, GeoMesh, PrimitiveField3 > &gf2)
Definition: GeometricFieldFunctions.C:1005
Foam::pow
tmp< DimensionedField< typename powProduct< Type, r >::type, GeoMesh, Field > > pow(const DimensionedField< Type, GeoMesh, PrimitiveField > &df, typename powProduct< Type, r >::type)
Definition: DimensionedFieldFunctions.C:61
Foam::cmptAv
tmp< DimensionedField< typename DimensionedField< Type, GeoMesh, PrimitiveField >::cmptType, GeoMesh, Field >> cmptAv(const DimensionedField< Type, GeoMesh, PrimitiveField > &df)
Definition: DimensionedFieldFunctions.C:291
Foam::mag
tmp< DimensionedField< scalar, GeoMesh, Field > > mag(const DimensionedField< Type, GeoMesh, PrimitiveField > &df)
Definition: DimensionedFieldFunctions.C:238
Foam::multiply
void multiply(pointPatchField< Type > &f, const pointPatchField< scalar > &f1, const pointPatchField< Type > &f2)
Definition: pointPatchFieldFunctions.H:155
Foam::negate
void negate(pointPatchField< Type > &f, const pointPatchField< Type > &f1)
Definition: pointPatchFieldFunctions.H:142
Foam::cmptMag
tmp< DimensionedField< Type, GeoMesh, Field > > cmptMag(const DimensionedField< Type, GeoMesh, PrimitiveField > &df)
Foam::magSqr
tmp< DimensionedField< scalar, GeoMesh, Field > > magSqr(const DimensionedField< Type, GeoMesh, PrimitiveField > &df)
Definition: DimensionedFieldFunctions.C:193
Foam::New
tmp< DimensionedField< TypeR, GeoMesh, Field > > New(const tmp< DimensionedField< TypeR, GeoMesh, Field >> &tdf1, const word &name, const dimensionSet &dimensions)
Definition: DimensionedFieldReuseFunctions.H:40
Foam::T
void T(GeometricField< Type, GeoMesh, PrimitiveField1 > &gf, const GeometricField< Type, GeoMesh, PrimitiveField2 > &gf1)
Definition: GeometricFieldFunctions.C:81
Foam::direction
uint8_t direction
Definition: direction.H:45
Foam::max
dimensioned< Type > max(const DimensionedField< Type, GeoMesh, PrimitiveField > &df)
Definition: DimensionedFieldFunctions.C:373
Foam::dot
void dot(GeometricField< typename innerProduct< Type1, Type2 >::type, GeoMesh, PrimitiveField1 > &gf, const GeometricField< Type1, GeoMesh, PrimitiveField2 > &gf1, const GeometricField< Type2, GeoMesh, PrimitiveField3 > &gf2)
Definition: GeometricFieldFunctions.C:1006
f
labelList f(nPoints)