FieldFunctions.C
Go to the documentation of this file.
1 /*---------------------------------------------------------------------------*\
2  ========= |
3  \\ / F ield | OpenFOAM: The Open Source CFD Toolbox
4  \\ / O peration |
5  \\ / A nd | www.openfoam.com
6  \\/ M anipulation |
7 -------------------------------------------------------------------------------
8  Copyright (C) 2011-2016 OpenFOAM Foundation
9  Copyright (C) 2019-2025 OpenCFD Ltd.
10 -------------------------------------------------------------------------------
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 #include "PstreamReduceOps.H"
30 #include "FieldReuseFunctions.H"
31 
32 #define TEMPLATE template<class Type>
33 #include "FieldFunctionsM.C"
34 
35 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
36 
37 namespace Foam
38 {
39 
40 /* * * * * * * * * * * * * * * * Global Functions * * * * * * * * * * * * * */
41 
42 template<class Type>
43 void component
44 (
45  Field<typename Field<Type>::cmptType>& result,
46  const UList<Type>& f1,
47  const direction d
48 )
49 {
50  typedef typename Field<Type>::cmptType resultType;
51 
52  TFOR_ALL_F_OP_F_FUNC_S
53  (
54  resultType, result, =, Type, f1, .component, const direction, d
55  )
56 }
57 
58 
59 template<class Type>
60 void T(Field<Type>& result, const UList<Type>& f1)
61 {
62  TFOR_ALL_F_OP_F_FUNC(Type, result, =, Type, f1, T)
63 }
64 
65 
66 template<class Type, direction r>
67 void pow
68 (
69  Field<typename powProduct<Type, r>::type>& result,
70  const UList<Type>& f1
71 )
72 {
73  typedef typename powProduct<Type, r>::type resultType;
74 
75  TFOR_ALL_F_OP_FUNC_F_S
76  (
77  resultType, result, =, pow, Type, f1, resultType,
78  pTraits<resultType>::zero
79  )
80 }
81 
82 template<class Type, direction r>
83 tmp<Field<typename powProduct<Type, r>::type>>
84 pow
85 (
86  const UList<Type>& f1,
87  typename powProduct<Type, r>::type
88 )
89 {
90  typedef typename powProduct<Type, r>::type resultType;
91  auto tres = tmp<Field<resultType>>::New(f1.size());
92  pow<Type, r>(tres.ref(), f1);
93  return tres;
94 }
95 
96 template<class Type, direction r>
97 tmp<Field<typename powProduct<Type, r>::type>>
98 pow
99 (
100  const tmp<Field<Type>>& tf1,
101  typename powProduct<Type, r>::type
102 )
103 {
104  typedef typename powProduct<Type, r>::type resultType;
105  auto tres = reuseTmp<resultType, Type>::New(tf1);
106  pow<Type, r>(tres.ref(), tf1());
107  tf1.clear();
108  return tres;
109 }
110 
111 
112 template<class Type>
113 void sqr
114 (
115  Field<typename outerProduct<Type, Type>::type>& result,
116  const UList<Type>& f1
117 )
118 {
119  typedef typename outerProduct<Type, Type>::type resultType;
120 
121  TFOR_ALL_F_OP_FUNC_F(resultType, result, =, sqr, Type, f1)
122 }
123 
124 template<class Type>
125 tmp<Field<typename outerProduct<Type, Type>::type>>
126 sqr(const UList<Type>& f1)
127 {
128  typedef typename outerProduct<Type, Type>::type resultType;
129  auto tres = tmp<Field<resultType>>::New(f1.size());
130  sqr(tres.ref(), f1);
131  return tres;
132 }
133 
134 template<class Type>
135 tmp<Field<typename outerProduct<Type, Type>::type>>
136 sqr(const tmp<Field<Type>>& tf1)
137 {
138  typedef typename outerProduct<Type, Type>::type resultType;
139  auto tres = reuseTmp<resultType, Type>::New(tf1);
140  sqr(tres.ref(), tf1());
141  tf1.clear();
142  return tres;
143 }
144 
145 
146 template<class Type>
147 void magSqr
148 (
149  Field<typename typeOfMag<Type>::type>& result,
150  const UList<Type>& f1
151 )
152 {
153  typedef typename typeOfMag<Type>::type resultType;
154 
155  TFOR_ALL_F_OP_FUNC_F(resultType, result, =, magSqr, Type, f1)
156 }
157 
158 template<class Type>
159 tmp<Field<typename typeOfMag<Type>::type>>
160 magSqr(const UList<Type>& f1)
161 {
162  typedef typename typeOfMag<Type>::type resultType;
163 
164  auto tres = tmp<Field<resultType>>::New(f1.size());
165  magSqr(tres.ref(), f1);
166  return tres;
167 }
168 
169 template<class Type>
170 tmp<Field<typename typeOfMag<Type>::type>>
171 magSqr(const tmp<Field<Type>>& tf1)
172 {
173  typedef typename typeOfMag<Type>::type resultType;
174 
175  auto tres = reuseTmp<resultType, Type>::New(tf1);
176  magSqr(tres.ref(), tf1());
177  tf1.clear();
178  return tres;
179 }
180 
181 
182 template<class Type>
183 void mag
184 (
185  Field<typename typeOfMag<Type>::type>& result,
186  const UList<Type>& f1
187 )
188 {
189  typedef typename typeOfMag<Type>::type resultType;
190 
191  TFOR_ALL_F_OP_FUNC_F(resultType, result, =, mag, Type, f1)
192 }
193 
194 template<class Type>
195 tmp<Field<typename typeOfMag<Type>::type>>
196 mag(const UList<Type>& f1)
197 {
198  typedef typename typeOfMag<Type>::type resultType;
199 
200  auto tres = tmp<Field<resultType>>::New(f1.size());
201  mag(tres.ref(), f1);
202  return tres;
203 }
204 
205 template<class Type>
206 tmp<Field<typename typeOfMag<Type>::type>>
207 mag(const tmp<Field<Type>>& tf1)
208 {
209  typedef typename typeOfMag<Type>::type resultType;
210 
211  auto tres = reuseTmp<resultType, Type>::New(tf1);
212  mag(tres.ref(), tf1());
213  tf1.clear();
214  return tres;
215 }
216 
217 
218 template<class Type>
219 void cmptMax
220 (
221  Field<typename Field<Type>::cmptType>& result,
222  const UList<Type>& f1
223 )
224 {
225  typedef typename Field<Type>::cmptType resultType;
226 
227  TFOR_ALL_F_OP_FUNC_F(resultType, result, =, cmptMax, Type, f1)
228 }
229 
230 template<class Type>
231 tmp<Field<typename Field<Type>::cmptType>> cmptMax(const UList<Type>& f1)
232 {
233  typedef typename Field<Type>::cmptType resultType;
234  auto tres = tmp<Field<resultType>>::New(f1.size());
235  cmptMax(tres.ref(), f1);
236  return tres;
237 }
238 
239 template<class Type>
240 tmp<Field<typename Field<Type>::cmptType>> cmptMax(const tmp<Field<Type>>& tf1)
241 {
242  typedef typename Field<Type>::cmptType resultType;
243  auto tres = reuseTmp<resultType, Type>::New(tf1);
244  cmptMax(tres.ref(), tf1());
245  tf1.clear();
246  return tres;
247 }
248 
249 
250 template<class Type>
251 void cmptMin
252 (
253  Field<typename Field<Type>::cmptType>& result,
254  const UList<Type>& f1
255 )
256 {
257  typedef typename Field<Type>::cmptType resultType;
258 
259  TFOR_ALL_F_OP_FUNC_F(resultType, result, =, cmptMin, Type, f1)
260 }
261 
262 template<class Type>
263 tmp<Field<typename Field<Type>::cmptType>> cmptMin(const UList<Type>& f1)
264 {
265  typedef typename Field<Type>::cmptType resultType;
266  auto tres = tmp<Field<resultType>>::New(f1.size());
267  cmptMin(tres.ref(), f1);
268  return tres;
269 }
270 
271 template<class Type>
272 tmp<Field<typename Field<Type>::cmptType>> cmptMin(const tmp<Field<Type>>& tf1)
273 {
274  typedef typename Field<Type>::cmptType resultType;
275  auto tres = reuseTmp<resultType, Type>::New(tf1);
276  cmptMin(tres.ref(), tf1());
277  tf1.clear();
278  return tres;
279 }
280 
281 
282 template<class Type>
283 void cmptAv
284 (
285  Field<typename Field<Type>::cmptType>& result,
286  const UList<Type>& f1
287 )
288 {
289  typedef typename Field<Type>::cmptType resultType;
290 
291  TFOR_ALL_F_OP_FUNC_F(resultType, result, =, cmptAv, Type, f1)
292 }
293 
294 template<class Type>
295 tmp<Field<typename Field<Type>::cmptType>> cmptAv(const UList<Type>& f1)
296 {
297  typedef typename Field<Type>::cmptType resultType;
298  auto tres = tmp<Field<resultType>>::New(f1.size());
299  cmptAv(tres.ref(), f1);
300  return tres;
301 }
302 
303 template<class Type>
304 tmp<Field<typename Field<Type>::cmptType>> cmptAv(const tmp<Field<Type>>& tf1)
305 {
306  typedef typename Field<Type>::cmptType resultType;
307  auto tres = reuseTmp<resultType, Type>::New(tf1);
308  cmptAv(tres.ref(), tf1());
309  tf1.clear();
310  return tres;
311 }
312 
313 
314 template<class Type>
315 void cmptMag(Field<Type>& result, const UList<Type>& f1)
316 {
317  TFOR_ALL_F_OP_FUNC_F(Type, result, =, cmptMag, Type, f1)
318 }
319 
320 template<class Type>
321 tmp<Field<Type>> cmptMag(const UList<Type>& f1)
322 {
323  auto tres = tmp<Field<Type>>::New(f1.size());
324  cmptMag(tres.ref(), f1);
325  return tres;
326 }
327 
328 template<class Type>
329 tmp<Field<Type>> cmptMag(const tmp<Field<Type>>& tf1)
330 {
331  auto tres = New(tf1);
332  cmptMag(tres.ref(), tf1());
333  tf1.clear();
334  return tres;
335 }
336 
337 
338 template<class Type>
339 void cmptMagSqr(Field<Type>& result, const UList<Type>& f1)
340 {
341  TFOR_ALL_F_OP_FUNC_F(Type, result, =, cmptMagSqr, Type, f1)
342 }
343 
344 template<class Type>
345 tmp<Field<Type>> cmptMagSqr(const UList<Type>& f1)
346 {
347  auto tres = tmp<Field<Type>>::New(f1.size());
348  cmptMagSqr(tres.ref(), f1);
349  return tres;
350 }
351 
352 template<class Type>
353 tmp<Field<Type>> cmptMagSqr(const tmp<Field<Type>>& tf1)
354 {
355  auto tres = New(tf1);
356  cmptMagSqr(tres.ref(), tf1());
357  tf1.clear();
358  return tres;
359 }
360 
361 
362 #define TMP_UNARY_FUNCTION(ReturnType, Func) \
363  \
364 template<class Type> \
365 ReturnType Func(const tmp<Field<Type>>& tf1) \
366 { \
367  ReturnType res = Func(tf1()); \
368  tf1.clear(); \
369  return res; \
370 }
371 
372 template<class Type>
373 Type max(const UList<Type>& f1)
374 {
375  if (f1.size())
376  {
377  Type result(f1[0]);
378  TFOR_ALL_S_OP_FUNC_F_S(Type, result, =, max, Type, f1, Type, result)
379  return result;
380  }
381 
382  return pTraits<Type>::min;
383 }
384 
385 TMP_UNARY_FUNCTION(Type, max)
386 
387 template<class Type>
388 Type min(const UList<Type>& f1)
389 {
390  if (f1.size())
391  {
392  Type result(f1[0]);
393  TFOR_ALL_S_OP_FUNC_F_S(Type, result, =, min, Type, f1, Type, result)
394  return result;
395  }
396 
397  return pTraits<Type>::max;
398 }
399 
400 TMP_UNARY_FUNCTION(Type, min)
401 
402 template<class Type>
403 Type sum(const UList<Type>& f1)
404 {
405  typedef typename Foam::typeOfSolve<Type>::type resultType;
406 
407  resultType result = Zero;
408 
409  if (f1.size())
410  {
411  // Use resultType() as functional cast
412  TFOR_ALL_S_OP_FUNC_F(resultType, result, +=, resultType, Type, f1)
413  }
414 
415  return Type(result);
416 }
417 
418 TMP_UNARY_FUNCTION(Type, sum)
419 
420 
421 // From MinMaxOps.H:
422 // - Foam::minMax(const UList<Type>&)
423 // - Foam::minMaxMag(const UList<Type>&)
424 
425 TMP_UNARY_FUNCTION(MinMax<Type>, minMax)
426 TMP_UNARY_FUNCTION(scalarMinMax, minMaxMag)
427 
428 
429 template<class Type>
430 Type maxMagSqr(const UList<Type>& f1)
431 {
432  if (f1.size())
433  {
434  Type result(f1[0]);
435  TFOR_ALL_S_OP_FUNC_F_S
436  (
437  Type,
438  result,
439  =,
440  maxMagSqrOp<Type>(),
441  Type,
442  f1,
443  Type,
444  result
445  )
446  return result;
447  }
448 
449  return Zero;
450 }
451 
452 TMP_UNARY_FUNCTION(Type, maxMagSqr)
453 
454 template<class Type>
455 Type minMagSqr(const UList<Type>& f1)
456 {
457  if (f1.size())
458  {
459  Type result(f1[0]);
460  TFOR_ALL_S_OP_FUNC_F_S
461  (
462  Type,
463  result,
464  =,
465  minMagSqrOp<Type>(),
466  Type,
467  f1,
468  Type,
469  result
470  )
471  return result;
472  }
473 
474  return pTraits<Type>::rootMax;
475 }
476 
477 TMP_UNARY_FUNCTION(Type, minMagSqr)
478 
479 template<class Type>
480 typename scalarProduct<Type, Type>::type
481 sumProd(const UList<Type>& f1, const UList<Type>& f2)
482 {
483  typedef typename scalarProduct<Type, Type>::type resultType;
484 
485  resultType result = Zero;
486  if (f1.size() && (f1.size() == f2.size()))
487  {
488  TFOR_ALL_S_OP_F_OP_F(resultType, result, +=, Type, f1, &&, Type, f2)
489  }
490  return result;
491 }
492 
493 
494 template<class Type>
495 Type sumCmptProd(const UList<Type>& f1, const UList<Type>& f2)
496 {
497  Type result = Zero;
498  if (f1.size() && (f1.size() == f2.size()))
499  {
500  TFOR_ALL_S_OP_FUNC_F_F
501  (
502  Type,
503  result,
504  +=,
505  cmptMultiply,
506  Type,
507  f1,
508  Type,
509  f2
510  )
511  }
512  return result;
513 }
514 
515 
516 template<class Type>
517 typename outerProduct1<Type>::type
518 sumSqr(const UList<Type>& f1)
519 {
520  typedef typename outerProduct1<Type>::type resultType;
521 
522  resultType result = Zero;
523  if (f1.size())
524  {
525  TFOR_ALL_S_OP_FUNC_F(resultType, result, +=, sqr, Type, f1)
526  }
527  return result;
528 }
529 
530 template<class Type>
531 typename outerProduct1<Type>::type
532 sumSqr(const tmp<Field<Type>>& tf1)
533 {
534  typedef typename outerProduct1<Type>::type resultType;
535  resultType result = sumSqr(tf1());
536  tf1.clear();
537  return result;
538 }
539 
540 
541 template<class Type>
542 typename typeOfMag<Type>::type
543 sumMag(const UList<Type>& f1)
544 {
545  typedef typename typeOfMag<Type>::type resultType;
546 
547  resultType result = Zero;
548  if (f1.size())
549  {
550  TFOR_ALL_S_OP_FUNC_F(resultType, result, +=, mag, Type, f1)
551  }
552  return result;
553 }
554 
555 TMP_UNARY_FUNCTION(typename typeOfMag<Type>::type, sumMag)
556 
557 
558 template<class Type>
559 Type sumCmptMag(const UList<Type>& f1)
560 {
561  Type result = Zero;
562  if (f1.size())
563  {
564  TFOR_ALL_S_OP_FUNC_F(Type, result, +=, cmptMag, Type, f1)
565  }
566  return result;
567 }
568 
569 TMP_UNARY_FUNCTION(Type, sumCmptMag)
570 
571 template<class Type>
572 Type average(const UList<Type>& f1)
573 {
574  if (f1.size())
575  {
576  Type result = sum(f1)/f1.size();
577 
578  return result;
579  }
580 
581  WarningInFunction
582  << "empty field, returning zero" << endl;
583 
584  return Zero;
585 }
586 
587 TMP_UNARY_FUNCTION(Type, average)
588 
589 
590 // With reduction on ReturnType
591 #define G_UNARY_FUNCTION(ReturnType, gFunc, Func, rFunc) \
592  \
593 template<class Type> \
594 ReturnType gFunc(const UList<Type>& f, const label comm) \
595 { \
596  ReturnType res = Func(f); \
597  Foam::reduce(res, rFunc##Op<ReturnType>(), UPstream::msgType(), comm); \
598  return res; \
599 } \
600 TMP_UNARY_FUNCTION(ReturnType, gFunc)
601 
602 G_UNARY_FUNCTION(Type, gMax, max, max)
603 G_UNARY_FUNCTION(Type, gMin, min, min)
604 G_UNARY_FUNCTION(Type, gSum, sum, sum)
605 G_UNARY_FUNCTION(Type, gMaxMagSqr, maxMagSqr, maxMagSqr)
606 G_UNARY_FUNCTION(Type, gMinMagSqr, minMagSqr, minMagSqr)
607 G_UNARY_FUNCTION(Type, gSumCmptMag, sumCmptMag, sum)
608 
609 G_UNARY_FUNCTION(MinMax<Type>, gMinMax, minMax, sum)
610 G_UNARY_FUNCTION(scalarMinMax, gMinMaxMag, minMaxMag, sum)
611 
612 G_UNARY_FUNCTION(typename outerProduct1<Type>::type, gSumSqr, sumSqr, sum)
613 G_UNARY_FUNCTION(typename typeOfMag<Type>::type, gSumMag, sumMag, sum)
614 
615 #undef G_UNARY_FUNCTION
616 
617 
618 template<class Type>
619 typename scalarProduct<Type, Type>::type gSumProd
620 (
621  const UList<Type>& f1,
622  const UList<Type>& f2,
623  const label comm
624 )
625 {
626  typedef typename scalarProduct<Type, Type>::type resultType;
627 
628  resultType result = sumProd(f1, f2);
629  Foam::reduce(result, sumOp<resultType>(), UPstream::msgType(), comm);
630  return result;
631 }
632 
633 template<class Type>
634 Type gSumCmptProd
635 (
636  const UList<Type>& f1,
637  const UList<Type>& f2,
638  const label comm
639 )
640 {
641  Type result = sumCmptProd(f1, f2);
642  Foam::reduce(result, sumOp<Type>(), UPstream::msgType(), comm);
643  return result;
644 }
645 
646 template<class Type>
647 Type gAverage
648 (
649  const UList<Type>& f1,
650  const label comm
651 )
652 {
653  label count = f1.size();
654  Type result = sum(f1);
655 
656  // Communicator is not disabled
657  if (comm >= 0)
658  {
659  Foam::sumReduce(result, count, UPstream::msgType(), comm);
660  }
661 
662  if (count > 0)
663  {
664  return result/count;
665  }
666 
667  WarningInFunction
668  << "empty field, returning zero." << endl;
669 
670  return Zero;
671 }
672 
673 TMP_UNARY_FUNCTION(Type, gAverage)
674 
675 
676 template<class Type>
677 Type gWeightedAverage
678 (
679  const UList<scalar>& weights,
680  const UList<Type>& fld,
681  const label comm
682 )
683 {
684  scalar weight(0);
685  Type result = Zero;
686 
687  const label loopLen = fld.size();
688 
689  /* pragmas... */
690  for (label i = 0; i < loopLen; ++i)
691  {
692  const scalar w = Foam::mag(weights[i]);
693  weight += w;
694  result += w*fld[i];
695  }
696 
697  // Communicator is not disabled
698  if (comm >= 0)
699  {
700  Foam::sumReduce(result, weight, UPstream::msgType(), comm);
701  }
702 
703  if (weight > ROOTVSMALL)
704  {
705  // With minimal rounding to protect against aggressive optimization
706  return result/(weight + ROOTVSMALL);
707  }
708  else
709  {
710  return Zero;
711  }
712 }
713 
714 
715 template<class Type>
716 Type gWeightedSum
717 (
718  const UList<scalar>& weights,
719  const UList<Type>& fld,
720  const label comm
721 )
722 {
723  Type result = Zero;
724 
725  const label loopLen = fld.size();
726 
727  /* pragmas... */
728  for (label i = 0; i < loopLen; ++i)
729  {
730  result += Foam::mag(weights[i])*fld[i];
731  }
732 
733  // Communicator is not disabled
734  if (comm >= 0)
735  {
736  Foam::reduce(result, sumOp<Type>(), UPstream::msgType(), comm);
737  }
738 
739  return result;
740 }
741 
742 
743 #undef TMP_UNARY_FUNCTION
744 
745 
746 // Implement BINARY_FUNCTION_TRANSFORM_FS for clamp
747 template<class Type>
748 void clamp
749 (
750  Field<Type>& result,
751  const UList<Type>& f1,
752  const MinMax<Type>& range
753 )
754 {
755  // Note: no checks for bad/invalid clamping ranges
756 
757  if (result.cdata() == f1.cdata())
758  {
759  // Apply in-place
760  result.clamp_range(range);
761  }
762  else
763  {
764  std::transform
765  (
766  f1.cbegin(),
767  f1.cbegin(result.size()),
768  result.begin(),
769  clampOp<Type>(range)
770  );
771  }
772 }
773 
774 template<class Type>
775 void clamp
776 (
777  Field<Type>& result,
778  const UList<Type>& f1,
779  const Foam::zero_one& // Note: macros generate a const reference
780 )
781 {
782  if (result.cdata() == f1.cdata())
783  {
784  // Apply in-place
785  result.clamp_range(Foam::zero_one{});
786  }
787  else
788  {
789  std::transform
790  (
791  f1.cbegin(),
792  f1.cbegin(result.size()),
793  result.begin(),
794  clampOp<Type>(Foam::zero_one{})
795  );
796  }
797 }
798 
799 BINARY_FUNCTION_INTERFACE_FS(Type, Type, MinMax<Type>, clamp)
800 BINARY_FUNCTION_INTERFACE_FS(Type, Type, Foam::zero_one, clamp)
801 
802 
803 BINARY_FUNCTION(Type, Type, Type, max)
804 BINARY_FUNCTION(Type, Type, Type, min)
805 BINARY_FUNCTION(Type, Type, Type, cmptMultiply)
806 BINARY_FUNCTION(Type, Type, Type, cmptDivide)
807 
808 BINARY_TYPE_FUNCTION(Type, Type, Type, max)
809 BINARY_TYPE_FUNCTION(Type, Type, Type, min)
810 BINARY_TYPE_FUNCTION(Type, Type, Type, cmptMultiply)
811 BINARY_TYPE_FUNCTION(Type, Type, Type, cmptDivide)
812 
813 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
814 
815 TERNARY_FUNCTION(Type, Type, Type, scalar, lerp)
816 TERNARY_TYPE_FUNCTION_FFS(Type, Type, Type, scalar, lerp)
817 
818 
819 /* * * * * * * * * * * * * * * * Global Operators * * * * * * * * * * * * * */
820 
821 UNARY_OPERATOR(Type, Type, -, negate)
822 
823 BINARY_OPERATOR(Type, Type, scalar, *, multiply)
824 BINARY_OPERATOR(Type, scalar, Type, *, multiply)
825 BINARY_OPERATOR(Type, Type, scalar, /, divide)
826 
827 BINARY_TYPE_OPERATOR_SF(Type, scalar, Type, *, multiply)
828 BINARY_TYPE_OPERATOR_FS(Type, Type, scalar, *, multiply)
829 
830 BINARY_TYPE_OPERATOR_FS(Type, Type, scalar, /, divide)
831 
832 
833 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
834 
835 #define PRODUCT_OPERATOR(product, Op, OpFunc) \
836  \
837 template<class Type1, class Type2> \
838 void OpFunc \
839 ( \
840  Field<typename product<Type1, Type2>::type>& result, \
841  const UList<Type1>& f1, \
842  const UList<Type2>& f2 \
843 ) \
844 { \
845  typedef typename product<Type1, Type2>::type resultType; \
846  TFOR_ALL_F_OP_F_OP_F(resultType, result, =, Type1, f1, Op, Type2, f2) \
847 } \
848  \
849 template<class Type1, class Type2> \
850 tmp<Field<typename product<Type1, Type2>::type>> \
851 operator Op(const UList<Type1>& f1, const UList<Type2>& f2) \
852 { \
853  typedef typename product<Type1, Type2>::type resultType; \
854  auto tres = tmp<Field<resultType>>::New(f1.size()); \
855  OpFunc(tres.ref(), f1, f2); \
856  return tres; \
857 } \
858  \
859 template<class Type1, class Type2> \
860 tmp<Field<typename product<Type1, Type2>::type>> \
861 operator Op(const UList<Type1>& f1, const tmp<Field<Type2>>& tf2) \
862 { \
863  typedef typename product<Type1, Type2>::type resultType; \
864  auto tres = reuseTmp<resultType, Type2>::New(tf2); \
865  OpFunc(tres.ref(), f1, tf2()); \
866  tf2.clear(); \
867  return tres; \
868 } \
869  \
870 template<class Type1, class Type2> \
871 tmp<Field<typename product<Type1, Type2>::type>> \
872 operator Op(const tmp<Field<Type1>>& tf1, const UList<Type2>& f2) \
873 { \
874  typedef typename product<Type1, Type2>::type resultType; \
875  auto tres = reuseTmp<resultType, Type1>::New(tf1); \
876  OpFunc(tres.ref(), tf1(), f2); \
877  tf1.clear(); \
878  return tres; \
879 } \
880  \
881 template<class Type1, class Type2> \
882 tmp<Field<typename product<Type1, Type2>::type>> \
883 operator Op(const tmp<Field<Type1>>& tf1, const tmp<Field<Type2>>& tf2) \
884 { \
885  typedef typename product<Type1, Type2>::type resultType; \
886  auto tres = reuseTmpTmp<resultType, Type1, Type1, Type2>::New(tf1, tf2); \
887  OpFunc(tres.ref(), tf1(), tf2()); \
888  tf1.clear(); \
889  tf2.clear(); \
890  return tres; \
891 } \
892  \
893 template<class Type, class Form, class Cmpt, direction nCmpt> \
894 void OpFunc \
895 ( \
896  Field<typename product<Type, Form>::type>& result, \
897  const UList<Type>& f1, \
898  const VectorSpace<Form,Cmpt,nCmpt>& vs \
899 ) \
900 { \
901  typedef typename product<Type, Form>::type resultType; \
902  TFOR_ALL_F_OP_F_OP_S \
903  (resultType, result, =,Type, f1, Op, Form, static_cast<const Form&>(vs))\
904 } \
905  \
906 template<class Type, class Form, class Cmpt, direction nCmpt> \
907 tmp<Field<typename product<Type, Form>::type>> \
908 operator Op(const UList<Type>& f1, const VectorSpace<Form,Cmpt,nCmpt>& vs) \
909 { \
910  typedef typename product<Type, Form>::type resultType; \
911  auto tres = tmp<Field<resultType>>::New(f1.size()); \
912  OpFunc(tres.ref(), f1, static_cast<const Form&>(vs)); \
913  return tres; \
914 } \
915  \
916 template<class Type, class Form, class Cmpt, direction nCmpt> \
917 tmp<Field<typename product<Type, Form>::type>> \
918 operator Op \
919 ( \
920  const tmp<Field<Type>>& tf1, \
921  const VectorSpace<Form,Cmpt,nCmpt>& vs \
922 ) \
923 { \
924  typedef typename product<Type, Form>::type resultType; \
925  auto tres = reuseTmp<resultType, Type>::New(tf1); \
926  OpFunc(tres.ref(), tf1(), static_cast<const Form&>(vs)); \
927  tf1.clear(); \
928  return tres; \
929 } \
930  \
931 template<class Form, class Cmpt, direction nCmpt, class Type> \
932 void OpFunc \
933 ( \
934  Field<typename product<Form, Type>::type>& result, \
935  const VectorSpace<Form,Cmpt,nCmpt>& vs, \
936  const UList<Type>& f1 \
937 ) \
938 { \
939  typedef typename product<Form, Type>::type resultType; \
940  TFOR_ALL_F_OP_S_OP_F \
941  (resultType, result, =,Form,static_cast<const Form&>(vs), Op, Type, f1)\
942 } \
943  \
944 template<class Form, class Cmpt, direction nCmpt, class Type> \
945 tmp<Field<typename product<Form, Type>::type>> \
946 operator Op(const VectorSpace<Form,Cmpt,nCmpt>& vs, const UList<Type>& f1) \
947 { \
948  typedef typename product<Form, Type>::type resultType; \
949  auto tres = tmp<Field<resultType>>::New(f1.size()); \
950  OpFunc(tres.ref(), static_cast<const Form&>(vs), f1); \
951  return tres; \
952 } \
953  \
954 template<class Form, class Cmpt, direction nCmpt, class Type> \
955 tmp<Field<typename product<Form, Type>::type>> \
956 operator Op \
957 ( \
958  const VectorSpace<Form,Cmpt,nCmpt>& vs, const tmp<Field<Type>>& tf1 \
959 ) \
960 { \
961  typedef typename product<Form, Type>::type resultType; \
962  auto tres = reuseTmp<resultType, Type>::New(tf1); \
963  OpFunc(tres.ref(), static_cast<const Form&>(vs), tf1()); \
964  tf1.clear(); \
965  return tres; \
966 }
967 
968 PRODUCT_OPERATOR(typeOfSum, +, add)
969 PRODUCT_OPERATOR(typeOfSum, -, subtract)
970 
971 PRODUCT_OPERATOR(outerProduct, *, outer)
972 PRODUCT_OPERATOR(crossProduct, ^, cross)
973 PRODUCT_OPERATOR(innerProduct, &, dot)
974 PRODUCT_OPERATOR(scalarProduct, &&, dotdot)
975 
976 #undef PRODUCT_OPERATOR
977 
978 
979 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
980 
981 } // End namespace Foam
982 
983 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
984 
985 #include "undefFieldFunctionsM.H"
986 
987 // ************************************************************************* //
Foam::UList::size
void size(const label n)
Older name for setAddressableSize.
Definition: UList.H:114
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
PstreamReduceOps.H
Inter-processor communication reduction functions.
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)
TMP_UNARY_FUNCTION
#define TMP_UNARY_FUNCTION(ReturnType, Func)
Definition: FieldFunctions.C:355
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::MinMax
A min/max value pair with additional methods. In addition to conveniently storing values...
Definition: HashSet.H:72
Foam::minMagSqr
Type minMagSqr(const UList< Type > &f1)
Definition: FieldFunctions.C:448
Foam::outerProduct1
Outer-product of identical types.
Definition: products.H:126
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
TFOR_ALL_F_OP_F_FUNC
#define TFOR_ALL_F_OP_F_FUNC(typeF1, f1, OP, typeF2, f2, FUNC)
Definition: FieldM.H:170
Foam::endl
Ostream & endl(Ostream &os)
Add newline and flush stream.
Definition: Ostream.H:529
Foam::reuseTmp::New
static tmp< Field< TypeR > > New(const Field< Type1 > &f1)
Pass-through to tmp New.
Definition: FieldReuseFunctions.H:39
Foam::pTraits
A traits class, which is primarily used for primitives and vector-space.
Definition: pTraits.H:61
Foam::New
tmp< DimensionedField< TypeR, GeoMesh > > New(const tmp< DimensionedField< TypeR, GeoMesh >> &tf1, const word &name, const dimensionSet &dimensions, const bool initCopy=false)
Global function forwards to reuseTmpDimensionedField::New.
Definition: DimensionedFieldReuseFunctions.H:124
Foam::gSumCmptMag
Type gSumCmptMag(const UList< Type > &f, const label comm)
Definition: FieldFunctions.C:600
Foam::Field::clamp_range
void clamp_range(const Type &lower, const Type &upper)
Clamp field values (in-place) to the specified range.
Definition: Field.C:712
BINARY_TYPE_OPERATOR_FS
#define BINARY_TYPE_OPERATOR_FS(ReturnType, Type1, Type2, Op, OpName, OpFunc)
Definition: DimensionedFieldFunctionsM.C:606
Foam::typeOfMag
The magnitude type for given argument.
Definition: products.H:92
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::UPstream::msgType
static int & msgType() noexcept
Message tag of standard messages.
Definition: UPstream.H:1787
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
TFOR_ALL_F_OP_FUNC_F
#define TFOR_ALL_F_OP_FUNC_F(typeF1, f1, OP, FUNC, typeF2, f2)
Definition: FieldM.H:148
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
range
scalar range
Definition: LISASMDCalcMethod1.H:12
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::reduce
void reduce(T &value, [[maybe_unused]] BinaryOp bop, [[maybe_unused]] const int tag=UPstream::msgType(), const int communicator=UPstream::worldComm)
Reduce inplace (cf. MPI Allreduce)
Definition: PstreamReduceOps.H:51
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
TFOR_ALL_S_OP_FUNC_F
#define TFOR_ALL_S_OP_FUNC_F(typeS, s, OP, FUNC, typeF, f)
Definition: FieldM.H:558
Foam::type
fileName::Type type(const fileName &name, const bool followLink=true)
Return the file type: DIRECTORY or FILE, normally following symbolic links.
Definition: POSIX.C:801
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::BitOps::count
unsigned int count(const UList< bool > &bools, const bool val=true)
Count number of &#39;true&#39; entries.
Definition: BitOps.H:73
Foam::gSumCmptProd
Type gSumCmptProd(const UList< Type > &f1, const UList< Type > &f2, const label comm)
Definition: FieldFunctions.C:628
Foam::clampOp
Unary function for applying component-wise clamping.
Definition: MinMaxOps.H:67
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::Field
Generic templated field type.
Definition: Field.H:63
G_UNARY_FUNCTION
#define G_UNARY_FUNCTION(ReturnType, gFunc, Func, rFunc)
Definition: FieldFunctions.C:584
TFOR_ALL_S_OP_FUNC_F_S
#define TFOR_ALL_S_OP_FUNC_F_S(typeS1, s1, OP, FUNC, typeF, f, typeS2, s2)
Definition: FieldM.H:259
TFOR_ALL_S_OP_FUNC_F_F
#define TFOR_ALL_S_OP_FUNC_F_F(typeS, s, OP, FUNC, typeF1, f1, typeF2, f2)
Definition: FieldM.H:215
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< Type >::begin
iterator begin() noexcept
Return an iterator to begin traversing the UList.
Definition: UListI.H:385
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
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::transform
refinementData transform(const tensor &, const refinementData val)
No-op rotational transform for base types.
Definition: refinementData.C:26
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
TFOR_ALL_S_OP_F_OP_F
#define TFOR_ALL_S_OP_F_OP_F(typeS, s, OP1, typeF1, f1, OP2, typeF2, f2)
Definition: FieldM.H:540
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
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
WarningInFunction
#define WarningInFunction
Report a warning using Foam::Warning.
Definition: messageStream.H:453
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:317
BINARY_FUNCTION_INTERFACE_FS
#define BINARY_FUNCTION_INTERFACE_FS(ReturnType, Type1, Type2, Func)
Definition: FieldFunctionsM.C:244
Foam::sumReduce
void sumReduce(T &value, CountType &count, [[maybe_unused]] const int tag=UPstream::msgType(), const int communicator=UPstream::worldComm)
Reduce inplace (cf. MPI Allreduce) the sum of value and counter (eg, for averaging) ...
Definition: PstreamReduceOps.H:253
Foam::UList::cbegin
const_iterator cbegin() const noexcept
Return const_iterator to begin traversing the constant UList.
Definition: UListI.H:399
UNARY_OPERATOR
#define UNARY_OPERATOR(ReturnType, Type1, Op, OpFunc, Dfunc)
Definition: DimensionedFieldFunctionsM.C:83
Foam::UList< Type >::cdata
const Type * cdata() const noexcept
Return pointer to the underlying array serving as data storage.
Definition: UListI.H:258
TERNARY_TYPE_FUNCTION_FFS
#define TERNARY_TYPE_FUNCTION_FFS(ReturnType, Type1, Type2, Type3, Func)
Definition: DimensionedFieldFunctionsM.C:910
Foam::tmp
A class for managing temporary objects.
Definition: HashPtrTable.H:50
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
PRODUCT_OPERATOR
#define PRODUCT_OPERATOR(product, Op, OpFunc)
Definition: FieldFunctions.C:828
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::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
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:237
Foam::Zero
static constexpr const zero Zero
Global zero (0)
Definition: zero.H:127