FieldFieldFunctions.C
Go to the documentation of this file.
1 /*---------------------------------------------------------------------------*\
2  ========= |
3  \\ / F ield | OpenFOAM: The Open Source CFD Toolbox
4  \\ / O peration | Website: https://openfoam.org
5  \\ / A nd | Copyright (C) 2011-2018 OpenFOAM Foundation
6  \\/ M anipulation |
7 -------------------------------------------------------------------------------
8 License
9  This file is part of OpenFOAM.
10 
11  OpenFOAM is free software: you can redistribute it and/or modify it
12  under the terms of the GNU General Public License as published by
13  the Free Software Foundation, either version 3 of the License, or
14  (at your option) any later version.
15 
16  OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
17  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
18  FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
19  for more details.
20 
21  You should have received a copy of the GNU General Public License
22  along with OpenFOAM. If not, see <http://www.gnu.org/licenses/>.
23 
24 \*---------------------------------------------------------------------------*/
25 
26 #include "PstreamReduceOps.H"
27 #include "FieldFieldReuseFunctions.H"
28 
29 #define TEMPLATE template<template<class> class Field, class Type>
30 #include "FieldFieldFunctionsM.C"
31 
32 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
33 
34 namespace Foam
35 {
36 
37 /* * * * * * * * * * * * * * * * Global functions * * * * * * * * * * * * * */
38 
39 template<template<class> class Field, class Type>
40 void component
41 (
42  FieldField<Field, typename FieldField<Field, Type>::cmptType>& sf,
43  const FieldField<Field, Type>& f,
44  const direction d
45 )
46 {
47  forAll(sf, i)
48  {
49  component(sf[i], f[i], d);
50  }
51 }
52 
53 
54 template<template<class> class Field, class Type>
55 void T(FieldField<Field, Type>& f1, const FieldField<Field, Type>& f2)
56 {
57  forAll(f1, i)
58  {
59  T(f1[i], f2[i]);
60  }
61 }
62 
63 
64 template<template<class> class Field, class Type, direction r>
65 void pow
66 (
67  FieldField<Field, typename powProduct<Type, r>::type>& f,
68  const FieldField<Field, Type>& vf
69 )
70 {
71  forAll(f, i)
72  {
73  pow(f[i], vf[i]);
74  }
75 }
76 
77 template<template<class> class Field, class Type, direction r>
78 tmp<FieldField<Field, typename powProduct<Type, r>::type>>
79 pow
80 (
81  const FieldField<Field, Type>& f, typename powProduct<Type, r>::type
82 )
83 {
84  typedef typename powProduct<Type, r>::type powProductType;
85  tmp<FieldField<Field, powProductType>> tRes
86  (
87  FieldField<Field, powProductType>::NewCalculatedType(f)
88  );
89  pow<Type, r>(tRes.ref(), f);
90  return tRes;
91 }
92 
93 template<template<class> class Field, class Type, direction r>
94 tmp<FieldField<Field, typename powProduct<Type, r>::type>>
95 pow
96 (
97  const tmp<FieldField<Field, Type>>& tf, typename powProduct<Type, r>::type
98 )
99 {
100  typedef typename powProduct<Type, r>::type powProductType;
101  tmp<FieldField<Field, powProductType>> tRes
102  (
103  reuseTmpFieldField<Field, powProductType, Type>::New(tf)
104  );
105  pow<Type, r>(tRes.ref(), tf());
106  tf.clear();
107  return tRes;
108 }
109 
110 
111 template<template<class> class Field, class Type>
112 void sqr
113 (
114  FieldField<Field, typename outerProduct<Type, Type>::type>& f,
115  const FieldField<Field, Type>& vf
116 )
117 {
118  forAll(f, i)
119  {
120  sqr(f[i], vf[i]);
121  }
122 }
123 
124 template<template<class> class Field, class Type>
125 tmp<FieldField<Field, typename outerProduct<Type, Type>::type>>
126 sqr(const FieldField<Field, Type>& f)
127 {
128  typedef typename outerProduct<Type, Type>::type outerProductType;
129  tmp<FieldField<Field, outerProductType>> tRes
130  (
131  FieldField<Field, outerProductType>::NewCalculatedType(f)
132  );
133  sqr(tRes.ref(), f);
134  return tRes;
135 }
136 
137 template<template<class> class Field, class Type>
138 tmp<FieldField<Field, typename outerProduct<Type, Type>::type>>
139 sqr(const tmp<FieldField<Field, Type>>& tf)
140 {
141  typedef typename outerProduct<Type, Type>::type outerProductType;
142  tmp<FieldField<Field, outerProductType>> tRes
143  (
144  reuseTmpFieldField<Field, outerProductType, Type>::New(tf)
145  );
146  sqr(tRes.ref(), tf());
147  tf.clear();
148  return tRes;
149 }
150 
151 
152 template<template<class> class Field, class Type>
153 void magSqr(FieldField<Field, scalar>& sf, const FieldField<Field, Type>& f)
154 {
155  forAll(sf, i)
156  {
157  magSqr(sf[i], f[i]);
158  }
159 }
160 
161 template<template<class> class Field, class Type>
162 tmp<FieldField<Field, scalar>> magSqr(const FieldField<Field, Type>& f)
163 {
164  tmp<FieldField<Field, scalar>> tRes
165  (
166  FieldField<Field, scalar>::NewCalculatedType(f)
167  );
168 
169  magSqr(tRes.ref(), f);
170  return tRes;
171 }
172 
173 template<template<class> class Field, class Type>
174 tmp<FieldField<Field, scalar>> magSqr(const tmp<FieldField<Field, Type>>& tf)
175 {
176  tmp<FieldField<Field, scalar>> tRes
177  (
178  reuseTmpFieldField<Field, scalar, Type>::New(tf)
179  );
180 
181  magSqr(tRes.ref(), tf());
182  tf.clear();
183  return tRes;
184 }
185 
186 
187 template<template<class> class Field, class Type>
188 void mag(FieldField<Field, scalar>& sf, const FieldField<Field, Type>& f)
189 {
190  forAll(sf, i)
191  {
192  mag(sf[i], f[i]);
193  }
194 }
195 
196 template<template<class> class Field, class Type>
197 tmp<FieldField<Field, scalar>> mag(const FieldField<Field, Type>& f)
198 {
199  tmp<FieldField<Field, scalar>> tRes
200  (
201  FieldField<Field, scalar>::NewCalculatedType(f)
202  );
203 
204  mag(tRes.ref(), f);
205  return tRes;
206 }
207 
208 template<template<class> class Field, class Type>
209 tmp<FieldField<Field, scalar>> mag(const tmp<FieldField<Field, Type>>& tf)
210 {
211  tmp<FieldField<Field, scalar>> tRes
212  (
213  reuseTmpFieldField<Field, scalar, Type>::New(tf)
214  );
215 
216  mag(tRes.ref(), tf());
217  tf.clear();
218  return tRes;
219 }
220 
221 
222 template<template<class> class Field, class Type>
223 void cmptMax
224 (
225  FieldField<Field, typename FieldField<Field, Type>::cmptType>& cf,
226  const FieldField<Field, Type>& f
227 )
228 {
229  forAll(cf, i)
230  {
231  cmptMax(cf[i], f[i]);
232  }
233 }
234 
235 template<template<class> class Field, class Type>
236 tmp<FieldField<Field, typename FieldField<Field, Type>::cmptType>> cmptMax
237 (
238  const FieldField<Field, Type>& f
239 )
240 {
241  typedef typename FieldField<Field, Type>::cmptType cmptType;
242  tmp<FieldField<Field, cmptType>> tRes
243  (
244  FieldField<Field, cmptType>::NewCalculatedType(f)
245  );
246  cmptMax(tRes.ref(), f);
247  return tRes;
248 }
249 
250 template<template<class> class Field, class Type>
251 tmp<FieldField<Field, typename FieldField<Field, Type>::cmptType>> cmptMax
252 (
253  const tmp<FieldField<Field, Type>>& tf
254 )
255 {
256  typedef typename FieldField<Field, Type>::cmptType cmptType;
257  tmp<FieldField<Field, cmptType>> tRes
258  (
259  reuseTmpFieldField<Field, cmptType, Type>::New(tf)
260  );
261  cmptMax(tRes.ref(), tf());
262  tf.clear();
263  return tRes;
264 }
265 
266 
267 template<template<class> class Field, class Type>
268 void cmptMin
269 (
270  FieldField<Field, typename FieldField<Field, Type>::cmptType>& cf,
271  const FieldField<Field, Type>& f
272 )
273 {
274  forAll(cf, i)
275  {
276  cmptMin(cf[i], f[i]);
277  }
278 }
279 
280 template<template<class> class Field, class Type>
281 tmp<FieldField<Field, typename FieldField<Field, Type>::cmptType>> cmptMin
282 (
283  const FieldField<Field, Type>& f
284 )
285 {
286  typedef typename FieldField<Field, Type>::cmptType cmptType;
287  tmp<FieldField<Field, cmptType>> tRes
288  (
289  FieldField<Field, cmptType>::NewCalculatedType(f)
290  );
291  cmptMin(tRes.ref(), f);
292  return tRes;
293 }
294 
295 template<template<class> class Field, class Type>
296 tmp<FieldField<Field, typename FieldField<Field, Type>::cmptType>> cmptMin
297 (
298  const tmp<FieldField<Field, Type>>& tf
299 )
300 {
301  typedef typename FieldField<Field, Type>::cmptType cmptType;
302  tmp<FieldField<Field, cmptType>> tRes
303  (
304  reuseTmpFieldField<Field, cmptType, Type>::New(tf)
305  );
306  cmptMin(tRes.ref(), tf());
307  tf.clear();
308  return tRes;
309 }
310 
311 
312 template<template<class> class Field, class Type>
313 void cmptAv
314 (
315  FieldField<Field, typename FieldField<Field, Type>::cmptType>& cf,
316  const FieldField<Field, Type>& f
317 )
318 {
319  forAll(cf, i)
320  {
321  cmptAv(cf[i], f[i]);
322  }
323 }
324 
325 template<template<class> class Field, class Type>
326 tmp<FieldField<Field, typename FieldField<Field, Type>::cmptType>> cmptAv
327 (
328  const FieldField<Field, Type>& f
329 )
330 {
331  typedef typename FieldField<Field, Type>::cmptType cmptType;
332  tmp<FieldField<Field, cmptType>> tRes
333  (
334  FieldField<Field, cmptType>::NewCalculatedType(f)
335  );
336  cmptAv(tRes.ref(), f);
337  return tRes;
338 }
339 
340 template<template<class> class Field, class Type>
341 tmp<FieldField<Field, typename FieldField<Field, Type>::cmptType>> cmptAv
342 (
343  const tmp<FieldField<Field, Type>>& tf
344 )
345 {
346  typedef typename FieldField<Field, Type>::cmptType cmptType;
347  tmp<FieldField<Field, cmptType>> tRes
348  (
349  reuseTmpFieldField<Field, cmptType, Type>::New(tf)
350  );
351  cmptAv(tRes.ref(), tf());
352  tf.clear();
353  return tRes;
354 }
355 
356 
357 template<template<class> class Field, class Type>
358 void cmptMag
359 (
360  FieldField<Field, Type>& cf,
361  const FieldField<Field, Type>& f
362 )
363 {
364  forAll(cf, i)
365  {
366  cmptMag(cf[i], f[i]);
367  }
368 }
369 
370 template<template<class> class Field, class Type>
371 tmp<FieldField<Field, Type>> cmptMag
372 (
373  const FieldField<Field, Type>& f
374 )
375 {
376  tmp<FieldField<Field, Type>> tRes
377  (
378  FieldField<Field, Type>::NewCalculatedType(f)
379  );
380  cmptMag(tRes.ref(), f);
381  return tRes;
382 }
383 
384 template<template<class> class Field, class Type>
385 tmp<FieldField<Field, Type>> cmptMag
386 (
387  const tmp<FieldField<Field, Type>>& tf
388 )
389 {
390  tmp<FieldField<Field, Type>> tRes(New(tf));
391  cmptMag(tRes.ref(), tf());
392  tf.clear();
393  return tRes;
394 }
395 
396 
397 #define TMP_UNARY_FUNCTION(returnType, func) \
398  \
399 template<template<class> class Field, class Type> \
400 returnType func(const tmp<FieldField<Field, Type>>& tf1) \
401 { \
402  returnType res = func(tf1()); \
403  tf1.clear(); \
404  return res; \
405 }
406 
407 template<template<class> class Field, class Type>
408 Type max(const FieldField<Field, Type>& f)
409 {
410  label i = 0;
411  while (i < f.size() && !f[i].size()) i++;
412 
413  if (i < f.size())
414  {
415  Type Max(max(f[i]));
416 
417  for (label j=i+1; j<f.size(); j++)
418  {
419  if (f[j].size())
420  {
421  Max = max(max(f[j]), Max);
422  }
423  }
424 
425  return Max;
426  }
427  else
428  {
429  return pTraits<Type>::min;
430  }
431 }
432 
433 TMP_UNARY_FUNCTION(Type, max)
434 
435 template<template<class> class Field, class Type>
436 Type min(const FieldField<Field, Type>& f)
437 {
438  label i = 0;
439  while (i < f.size() && !f[i].size()) i++;
440 
441  if (i < f.size())
442  {
443  label i = 0;
444  while (!f[i].size()) i++;
445 
446  Type Min(min(f[i]));
447 
448  for (label j=i+1; j<f.size(); j++)
449  {
450  if (f[j].size())
451  {
452  Min = min(min(f[j]), Min);
453  }
454  }
455 
456  return Min;
457  }
458  else
459  {
460  return pTraits<Type>::max;
461  }
462 }
463 
464 TMP_UNARY_FUNCTION(Type, min)
465 
466 template<template<class> class Field, class Type>
467 Type sum(const FieldField<Field, Type>& f)
468 {
469  if (f.size())
470  {
471  Type Sum = Zero;
472 
473  forAll(f, i)
474  {
475  Sum += sum(f[i]);
476  }
477 
478  return Sum;
479  }
480  else
481  {
482  return Zero;
483  }
484 }
485 
486 TMP_UNARY_FUNCTION(Type, sum)
487 
488 template<template<class> class Field, class Type>
489 scalar sumMag(const FieldField<Field, Type>& f)
490 {
491  if (f.size())
492  {
493  scalar SumMag = 0.0;
494 
495  forAll(f, i)
496  {
497  SumMag += sumMag(f[i]);
498  }
499 
500  return SumMag;
501  }
502  else
503  {
504  return 0.0;
505  }
506 }
507 
508 TMP_UNARY_FUNCTION(scalar, sumMag)
509 
510 template<template<class> class Field, class Type>
511 Type average(const FieldField<Field, Type>& f)
512 {
513  if (f.size())
514  {
515  label n = 0;
516 
517  forAll(f, i)
518  {
519  n += f[i].size();
520  }
521 
522  if (n == 0)
523  {
524  WarningInFunction
525  << "empty fieldField, returning zero" << endl;
526 
527  return Zero;
528  }
529 
530  Type avrg = sum(f)/n;
531 
532  return avrg;
533  }
534  else
535  {
536  WarningInFunction
537  << "empty fieldField, returning zero" << endl;
538 
539  return Zero;
540  }
541 }
542 
543 TMP_UNARY_FUNCTION(Type, average)
544 
545 
546 #define G_UNARY_FUNCTION(returnType, gFunc, func, rFunc) \
547  \
548 template<template<class> class Field, class Type> \
549 returnType gFunc(const FieldField<Field, Type>& f) \
550 { \
551  returnType res = func(f); \
552  reduce(res, rFunc##Op<Type>()); \
553  return res; \
554 } \
555 TMP_UNARY_FUNCTION(returnType, gFunc)
556 
557 G_UNARY_FUNCTION(Type, gMax, max, max)
558 G_UNARY_FUNCTION(Type, gMin, min, min)
559 G_UNARY_FUNCTION(Type, gSum, sum, sum)
560 G_UNARY_FUNCTION(scalar, gSumMag, sumMag, sum)
561 
562 #undef G_UNARY_FUNCTION
563 
564 
565 template<template<class> class Field, class Type>
566 Type gAverage(const FieldField<Field, Type>& f)
567 {
568  label n = 0;
569 
570  forAll(f, i)
571  {
572  n += f[i].size();
573  }
574 
575  reduce(n, sumOp<label>());
576 
577  if (n > 0)
578  {
579  Type avrg = gSum(f)/n;
580 
581  return avrg;
582  }
583  else
584  {
585  WarningInFunction
586  << "empty fieldField, returning zero" << endl;
587 
588  return Zero;
589  }
590 }
591 
592 TMP_UNARY_FUNCTION(Type, gAverage)
593 
594 #undef TMP_UNARY_FUNCTION
595 
596 
597 BINARY_FUNCTION(Type, Type, Type, max)
598 BINARY_FUNCTION(Type, Type, Type, min)
599 BINARY_FUNCTION(Type, Type, Type, cmptMultiply)
600 BINARY_FUNCTION(Type, Type, Type, cmptDivide)
601 
602 BINARY_TYPE_FUNCTION(Type, Type, Type, max)
603 BINARY_TYPE_FUNCTION(Type, Type, Type, min)
604 BINARY_TYPE_FUNCTION(Type, Type, Type, cmptMultiply)
605 BINARY_TYPE_FUNCTION(Type, Type, Type, cmptDivide)
606 
607 
608 /* * * * * * * * * * * * * * * * Global operators * * * * * * * * * * * * * */
609 
610 UNARY_OPERATOR(Type, Type, -, negate)
611 
612 BINARY_OPERATOR(Type, Type, scalar, *, multiply)
613 BINARY_OPERATOR(Type, scalar, Type, *, multiply)
614 BINARY_OPERATOR(Type, Type, scalar, /, divide)
615 
616 BINARY_TYPE_OPERATOR_SF(Type, scalar, Type, *, multiply)
617 BINARY_TYPE_OPERATOR_FS(Type, Type, scalar, *, multiply)
618 
619 BINARY_TYPE_OPERATOR_FS(Type, Type, scalar, /, divide)
620 
621 
622 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
623 
624 #define PRODUCT_OPERATOR(product, op, opFunc) \
625  \
626 template \
627 < \
628  template<class> class Field1, \
629  template<class> class Field2, \
630  class Type1, \
631  class Type2 \
632 > \
633 void opFunc \
634 ( \
635  FieldField<Field1, typename product<Type1, Type2>::type>& f, \
636  const FieldField<Field1, Type1>& f1, \
637  const FieldField<Field2, Type2>& f2 \
638 ) \
639 { \
640  forAll(f, i) \
641  { \
642  opFunc(f[i], f1[i], f2[i]); \
643  } \
644 } \
645  \
646 template \
647 < \
648  template<class> class Field1, \
649  template<class> class Field2, \
650  class Type1, \
651  class Type2 \
652 > \
653 tmp<FieldField<Field1, typename product<Type1, Type2>::type>> \
654 operator op \
655 ( \
656  const FieldField<Field1, Type1>& f1, \
657  const FieldField<Field2, Type2>& f2 \
658 ) \
659 { \
660  typedef typename product<Type1, Type2>::type productType; \
661  tmp<FieldField<Field1, productType>> tRes \
662  ( \
663  FieldField<Field1, productType>::NewCalculatedType(f1) \
664  ); \
665  opFunc(tRes.ref(), f1, f2); \
666  return tRes; \
667 } \
668  \
669 template<template<class> class Field, class Type1, class Type2> \
670 tmp<FieldField<Field, typename product<Type1, Type2>::type>> \
671 operator op \
672 ( \
673  const FieldField<Field, Type1>& f1, \
674  const tmp<FieldField<Field, Type2>>& tf2 \
675 ) \
676 { \
677  typedef typename product<Type1, Type2>::type productType; \
678  tmp<FieldField<Field, productType>> tRes \
679  ( \
680  reuseTmpFieldField<Field, productType, Type2>::New(tf2) \
681  ); \
682  opFunc(tRes.ref(), f1, tf2()); \
683  tf2.clear(); \
684  return tRes; \
685 } \
686  \
687 template \
688 < \
689  template<class> class Field1, \
690  template<class> class Field2, \
691  class Type1, \
692  class Type2 \
693 > \
694 tmp<FieldField<Field, typename product<Type1, Type2>::type>> \
695 operator op \
696 ( \
697  const FieldField<Field1, Type1>& f1, \
698  const tmp<FieldField<Field2, Type2>>& tf2 \
699 ) \
700 { \
701  typedef typename product<Type1, Type2>::type productType; \
702  tmp<FieldField<Field1, productType>> tRes \
703  ( \
704  FieldField<Field1, productType>::NewCalculatedType(f1) \
705  ); \
706  opFunc(tRes.ref(), f1, tf2()); \
707  tf2.clear(); \
708  return tRes; \
709 } \
710  \
711 template \
712 < \
713  template<class> class Field1, \
714  template<class> class Field2, \
715  class Type1, \
716  class Type2 \
717 > \
718 tmp<FieldField<Field1, typename product<Type1, Type2>::type>> \
719 operator op \
720 ( \
721  const tmp<FieldField<Field1, Type1>>& tf1, \
722  const FieldField<Field2, Type2>& f2 \
723 ) \
724 { \
725  typedef typename product<Type1, Type2>::type productType; \
726  tmp<FieldField<Field1, productType>> tRes \
727  ( \
728  reuseTmpFieldField<Field1, productType, Type1>::New(tf1) \
729  ); \
730  opFunc(tRes.ref(), tf1(), f2); \
731  tf1.clear(); \
732  return tRes; \
733 } \
734  \
735 template \
736 < \
737  template<class> class Field1, \
738  template<class> class Field2, \
739  class Type1, \
740  class Type2 \
741 > \
742 tmp<FieldField<Field1, typename product<Type1, Type2>::type>> \
743 operator op \
744 ( \
745  const tmp<FieldField<Field1, Type1>>& tf1, \
746  const tmp<FieldField<Field2, Type2>>& tf2 \
747 ) \
748 { \
749  typedef typename product<Type1, Type2>::type productType; \
750  tmp<FieldField<Field1, productType>> tRes \
751  ( \
752  reuseTmpTmpFieldField<Field1, productType, Type1, Type1, Type2>::New \
753  (tf1, tf2) \
754  ); \
755  opFunc(tRes.ref(), tf1(), tf2()); \
756  tf1.clear(); \
757  tf2.clear(); \
758  return tRes; \
759 } \
760  \
761 template \
762 < \
763  template<class> class Field, \
764  class Type, \
765  class Form, \
766  class Cmpt, \
767  direction nCmpt \
768 > \
769 void opFunc \
770 ( \
771  FieldField<Field, typename product<Type, Form>::type>& f, \
772  const FieldField<Field, Type>& f1, \
773  const VectorSpace<Form,Cmpt,nCmpt>& vs \
774 ) \
775 { \
776  forAll(f, i) \
777  { \
778  opFunc(f[i], f1[i], vs); \
779  } \
780 } \
781  \
782 template \
783 < \
784  template<class> class Field, \
785  class Type, \
786  class Form, \
787  class Cmpt, \
788  direction nCmpt \
789 > \
790 tmp<FieldField<Field, typename product<Type, Form>::type>> \
791 operator op \
792 ( \
793  const FieldField<Field, Type>& f1, \
794  const VectorSpace<Form,Cmpt,nCmpt>& vs \
795 ) \
796 { \
797  typedef typename product<Type, Form>::type productType; \
798  tmp<FieldField<Field, productType>> tRes \
799  ( \
800  FieldField<Field, productType>::NewCalculatedType(f1) \
801  ); \
802  opFunc(tRes.ref(), f1, static_cast<const Form&>(vs)); \
803  return tRes; \
804 } \
805  \
806 template \
807 < \
808  template<class> class Field, \
809  class Type, \
810  class Form, \
811  class Cmpt, \
812  direction nCmpt \
813 > \
814 tmp<FieldField<Field, typename product<Type, Form>::type>> \
815 operator op \
816 ( \
817  const tmp<FieldField<Field, Type>>& tf1, \
818  const VectorSpace<Form,Cmpt,nCmpt>& vs \
819 ) \
820 { \
821  typedef typename product<Type, Form>::type productType; \
822  tmp<FieldField<Field, productType>> tRes \
823  ( \
824  reuseTmpFieldField<Field, productType, Type>::New(tf1) \
825  ); \
826  opFunc(tRes.ref(), tf1(), static_cast<const Form&>(vs)); \
827  tf1.clear(); \
828  return tRes; \
829 } \
830  \
831 template \
832 < \
833  template<class> class Field, \
834  class Type, \
835  class Form, \
836  class Cmpt, \
837  direction nCmpt \
838 > \
839 void opFunc \
840 ( \
841  FieldField<Field, typename product<Form, Type>::type>& f, \
842  const VectorSpace<Form,Cmpt,nCmpt>& vs, \
843  const FieldField<Field, Type>& f1 \
844 ) \
845 { \
846  forAll(f, i) \
847  { \
848  opFunc(f[i], vs, f1[i]); \
849  } \
850 } \
851  \
852 template \
853 < \
854  template<class> class Field, \
855  class Type, \
856  class Form, \
857  class Cmpt, \
858  direction nCmpt \
859 > \
860 tmp<FieldField<Field, typename product<Form, Type>::type>> \
861 operator op \
862 ( \
863  const VectorSpace<Form,Cmpt,nCmpt>& vs, \
864  const FieldField<Field, Type>& f1 \
865 ) \
866 { \
867  typedef typename product<Form, Type>::type productType; \
868  tmp<FieldField<Field, productType>> tRes \
869  ( \
870  FieldField<Field, productType>::NewCalculatedType(f1) \
871  ); \
872  opFunc(tRes.ref(), static_cast<const Form&>(vs), f1); \
873  return tRes; \
874 } \
875  \
876 template \
877 < \
878  template<class> class Field, \
879  class Type, \
880  class Form, \
881  class Cmpt, \
882  direction nCmpt \
883 > \
884 tmp<FieldField<Field, typename product<Form, Type>::type>> \
885 operator op \
886 ( \
887  const VectorSpace<Form,Cmpt,nCmpt>& vs, \
888  const tmp<FieldField<Field, Type>>& tf1 \
889 ) \
890 { \
891  typedef typename product<Form, Type>::type productType; \
892  tmp<FieldField<Field, productType>> tRes \
893  ( \
894  reuseTmpFieldField<Field, productType, Type>::New(tf1) \
895  ); \
896  opFunc(tRes.ref(), static_cast<const Form&>(vs), tf1()); \
897  tf1.clear(); \
898  return tRes; \
899 }
900 
901 PRODUCT_OPERATOR(typeOfSum, +, add)
902 PRODUCT_OPERATOR(typeOfSum, -, subtract)
903 
904 PRODUCT_OPERATOR(outerProduct, *, outer)
905 PRODUCT_OPERATOR(crossProduct, ^, cross)
906 PRODUCT_OPERATOR(innerProduct, &, dot)
907 PRODUCT_OPERATOR(scalarProduct, &&, dotdot)
908 
909 #undef PRODUCT_OPERATOR
910 
911 
912 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
913 
914 } // End namespace Foam
915 
916 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
917 
918 #include "undefFieldFunctionsM.H"
919 
920 // ************************************************************************* //
Foam::divide
void divide(FieldField< Field, Type > &f, const FieldField< Field, Type > &f1, const FieldField< Field, scalar > &f2)
Foam::cmptMax
void cmptMax(FieldField< Field, typename FieldField< Field, Type >::cmptType > &cf, const FieldField< Field, Type > &f)
Definition: FieldFieldFunctions.C:224
forAll
#define forAll(list, i)
Loop across all elements in list.
Definition: UList.H:434
BINARY_OPERATOR
#define BINARY_OPERATOR(ReturnType, Type1, Type2, Op, OpName, OpFunc)
Definition: DimensionedFieldFunctionsM.C:392
Foam::multiply
void multiply(FieldField< Field, Type > &f, const FieldField< Field, Type > &f1, const FieldField< Field, scalar > &f2)
Foam::label
intWM_LABEL_SIZE_t label
A label is an int32_t or int64_t as specified by the pre-processor macro WM_LABEL_SIZE.
Definition: label.H:59
PstreamReduceOps.H
Inter-processor communication reduction functions.
Foam::max
dimensioned< Type > max(const dimensioned< Type > &, const dimensioned< Type > &)
Foam::cmptAv
tmp< DimensionedField< typename DimensionedField< Type, GeoMesh >::cmptType, GeoMesh >> cmptAv(const DimensionedField< Type, GeoMesh > &df)
Definition: DimensionedFieldFunctions.C:232
Foam::tmp::ref
T & ref() const
Return non-const reference or generate a fatal error.
Definition: tmpI.H:174
Foam::sqr
dimensionedSymmTensor sqr(const dimensionedVector &dv)
Definition: dimensionedSymmTensor.C:49
Foam::direction
uint8_t direction
Definition: direction.H:45
BINARY_TYPE_OPERATOR_SF
#define BINARY_TYPE_OPERATOR_SF(ReturnType, Type1, Type2, Op, OpName, OpFunc)
Definition: DimensionedFieldFunctionsM.C:501
Foam::endl
Ostream & endl(Ostream &os)
Add newline and flush stream.
Definition: Ostream.H:251
Foam::pTraits
Traits class for primitives.
Definition: pTraits.H:50
BINARY_TYPE_OPERATOR_FS
#define BINARY_TYPE_OPERATOR_FS(ReturnType, Type1, Type2, Op, OpName, OpFunc)
Definition: DimensionedFieldFunctionsM.C:573
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:905
Foam::outerProduct::type
typeOfRank< typename pTraits< arg1 >::cmptType, direction(pTraits< arg1 >::rank)+direction(pTraits< arg2 >::rank) >::type type
Definition: products.H:90
BINARY_TYPE_FUNCTION
#define BINARY_TYPE_FUNCTION(ReturnType, Type1, Type2, Func)
Definition: DimensionedFieldFunctionsM.C:385
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:907
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:902
tf
const tensorField & tf
Definition: getPatchFieldTensor.H:36
f1
scalar f1
Definition: createFields.H:28
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:904
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:906
Foam::FieldField
Generic field type.
Definition: FieldField.H:51
Foam::cmptDivide
dimensioned< Type > cmptDivide(const dimensioned< Type > &, const dimensioned< Type > &)
Foam::sum
dimensioned< Type > sum(const DimensionedField< Type, GeoMesh > &df)
Definition: DimensionedFieldFunctions.C:308
Foam::New
tmp< DimensionedField< TypeR, GeoMesh > > New(const tmp< DimensionedField< TypeR, GeoMesh >> &tdf1, const word &name, const dimensionSet &dimensions)
Definition: DimensionedFieldReuseFunctions.H:38
BINARY_FUNCTION
#define BINARY_FUNCTION(ReturnType, Type1, Type2, Func)
Definition: DimensionedFieldFunctionsM.C:132
Foam::gSum
Type gSum(const FieldField< Field, Type > &f)
Definition: FieldFieldFunctions.C:559
Foam::Field
Pre-declare SubField and related Field type.
Definition: Field.H:56
Foam::List::clear
void clear()
Clear the list, i.e. set size to zero.
Definition: ListI.H:125
TMP_UNARY_FUNCTION
#define TMP_UNARY_FUNCTION(returnType, func)
Definition: FieldFieldFunctions.C:397
Foam::Zero
static const zero Zero
Definition: zero.H:97
Foam::average
dimensioned< Type > average(const DimensionedField< Type, GeoMesh > &df)
Definition: DimensionedFieldFunctions.C:310
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:359
Foam::magSqr
dimensioned< scalar > magSqr(const dimensioned< Type > &)
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:901
Foam::gMax
Type gMax(const FieldField< Field, Type > &f)
Definition: FieldFieldFunctions.C:557
f
labelList f(nPoints)
Foam::T
void T(FieldField< Field, Type > &f1, const FieldField< Field, Type > &f2)
Definition: FieldFieldFunctions.C:55
Foam::min
dimensioned< Type > min(const dimensioned< Type > &, const dimensioned< Type > &)
sf
volScalarField sf(fieldObject, mesh)
Foam::reduce
void reduce(const List< UPstream::commsStruct > &comms, T &Value, const BinaryOp &bop, const int tag, const label comm)
Definition: PstreamReduceOps.H:49
Foam::powProduct::type
symmTypeOfRank< typename pTraits< arg1 >::cmptType, arg2 *direction(pTraits< arg1 >::rank) >::type type
Definition: products.H:136
Foam::UPtrList::size
label size() const
Return the number of elements in the UPtrList.
Definition: UPtrListI.H:29
Foam::pow
dimensionedScalar pow(const dimensionedScalar &ds, const dimensionedScalar &expt)
Definition: dimensionedScalar.C:73
PRODUCT_OPERATOR
#define PRODUCT_OPERATOR(product, op, opFunc)
Definition: FieldFieldFunctions.C:624
Foam::negate
void negate(FieldField< Field, Type > &res, const FieldField< Field, Type > &f)
Foam::FieldField::cmptType
pTraits< Type >::cmptType cmptType
Component type.
Definition: FieldField.H:82
WarningInFunction
#define WarningInFunction
Report a warning using Foam::Warning.
Definition: messageStream.H:260
Foam::gAverage
Type gAverage(const FieldField< Field, Type > &f)
Definition: FieldFieldFunctions.C:566
Foam::mag
dimensioned< scalar > mag(const dimensioned< Type > &)
n
label n
Definition: TABSMDCalcMethod2.H:31
G_UNARY_FUNCTION
#define G_UNARY_FUNCTION(returnType, gFunc, func, rFunc)
Definition: FieldFieldFunctions.C:546
UNARY_OPERATOR
#define UNARY_OPERATOR(ReturnType, Type1, Op, OpFunc, Dfunc)
Definition: DimensionedFieldFunctionsM.C:81
Foam::tmp
A class for managing temporary objects.
Definition: PtrList.H:53
Foam::cmptMin
void cmptMin(FieldField< Field, typename FieldField< Field, Type >::cmptType > &cf, const FieldField< Field, Type > &f)
Definition: FieldFieldFunctions.C:269
Foam::component
void component(FieldField< Field, typename FieldField< Field, Type >::cmptType > &sf, const FieldField< Field, Type > &f, const direction d)
Definition: FieldFieldFunctions.C:41
Foam
Namespace for OpenFOAM.
Definition: atmBoundaryLayer.H:213
Foam::sumMag
dimensioned< scalar > sumMag(const DimensionedField< Type, GeoMesh > &df)
Definition: DimensionedFieldFunctions.C:309