FreeFOAM The Cross-Platform CFD Toolkit
FieldFieldFunctions.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 | Copyright (C) 1991-2010 OpenCFD Ltd.
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 
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 (
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>
56 {
57  forAll(f1, i)
58  {
59  T(f1[i], f2[i]);
60  }
61 }
62 
63 
64 template<template<class> class Field, class Type, int r>
65 void pow
66 (
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, int r>
79 pow
80 (
82 )
83 {
84  typedef typename powProduct<Type, r>::type powProductType;
86  (
88  );
89  pow<Type, r>(tRes(), f);
90  return tRes;
91 }
92 
93 template<template<class> class Field, class Type, int r>
95 pow
96 (
98 )
99 {
100  typedef typename powProduct<Type, r>::type powProductType;
102  (
104  );
105  pow<Type, r>(tRes(), tf());
107  return tRes;
108 }
109 
110 
111 template<template<class> class Field, class Type>
112 void sqr
113 (
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>
127 {
128  typedef typename outerProduct<Type, Type>::type outerProductType;
130  (
132  );
133  sqr(tRes(), f);
134  return tRes;
135 }
136 
137 template<template<class> class Field, class Type>
140 {
141  typedef typename outerProduct<Type, Type>::type outerProductType;
143  (
145  );
146  sqr(tRes(), tf());
148  return tRes;
149 }
150 
151 
152 template<template<class> class Field, class Type>
154 {
155  forAll(sf, i)
156  {
157  magSqr(sf[i], f[i]);
158  }
159 }
160 
161 template<template<class> class Field, class Type>
163 {
165  (
167  );
168 
169  magSqr(tRes(), f);
170  return tRes;
171 }
172 
173 template<template<class> class Field, class Type>
175 {
177  (
179  );
180 
181  magSqr(tRes(), tf());
183  return tRes;
184 }
185 
186 
187 template<template<class> class Field, class Type>
189 {
190  forAll(sf, i)
191  {
192  mag(sf[i], f[i]);
193  }
194 }
195 
196 template<template<class> class Field, class Type>
198 {
200  (
202  );
203 
204  mag(tRes(), f);
205  return tRes;
206 }
207 
208 template<template<class> class Field, class Type>
210 {
212  (
214  );
215 
216  mag(tRes(), tf());
218  return tRes;
219 }
220 
221 
222 template<template<class> class Field, class Type>
223 void cmptMax
224 (
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;
243  (
245  );
246  cmptMax(tRes(), 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 (
254 )
255 {
256  typedef typename FieldField<Field, Type>::cmptType cmptType;
258  (
260  );
261  cmptMax(tRes(), tf());
263  return tRes;
264 }
265 
266 
267 template<template<class> class Field, class Type>
268 void cmptMin
269 (
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;
288  (
290  );
291  cmptMin(tRes(), 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 (
299 )
300 {
301  typedef typename FieldField<Field, Type>::cmptType cmptType;
303  (
305  );
306  cmptMin(tRes(), tf());
308  return tRes;
309 }
310 
311 
312 template<template<class> class Field, class Type>
313 void cmptAv
314 (
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;
333  (
335  );
336  cmptAv(tRes(), 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 (
344 )
345 {
346  typedef typename FieldField<Field, Type>::cmptType cmptType;
348  (
350  );
351  cmptAv(tRes(), tf());
353  return tRes;
354 }
355 
356 
357 template<template<class> class Field, class Type>
358 void cmptMag
359 (
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 {
377  (
379  );
380  cmptMag(tRes(), f);
381  return tRes;
382 }
383 
384 template<template<class> class Field, class Type>
385 tmp<FieldField<Field, Type> > cmptMag
386 (
388 )
389 {
391  (
393  );
394  cmptMag(tRes(), tf());
396  return tRes;
397 }
398 
399 
400 #define TMP_UNARY_FUNCTION(returnType, func) \
401  \
402 template<template<class> class Field, class Type> \
403 returnType func(const tmp<FieldField<Field, Type> >& tf1) \
404 { \
405  returnType res = func(tf1()); \
406  tf1.clear(); \
407  return res; \
408 }
409 
410 template<template<class> class Field, class Type>
412 {
413  label i = 0;
414  while(i < f.size() && !f[i].size()) i++;
415 
416  if (i < f.size())
417  {
418  Type Max(max(f[i]));
419 
420  for (label j=i+1; j<f.size(); j++)
421  {
422  if (f[j].size())
423  {
424  Max = max(max(f[j]), Max);
425  }
426  }
427 
428  return Max;
429  }
430  else
431  {
432  return pTraits<Type>::min;
433  }
434 }
435 
437 
438 template<template<class> class Field, class Type>
439 Type min(const FieldField<Field, Type>& f)
440 {
441  label i = 0;
442  while(i < f.size() && !f[i].size()) i++;
443 
444  if (i < f.size())
445  {
446  label i = 0;
447  while(!f[i].size()) i++;
448 
449  Type Min(min(f[i]));
450 
451  for (label j=i+1; j<f.size(); j++)
452  {
453  if (f[j].size())
454  {
455  Min = min(min(f[j]), Min);
456  }
457  }
458 
459  return Min;
460  }
461  else
462  {
463  return pTraits<Type>::max;
464  }
465 }
466 
468 
469 template<template<class> class Field, class Type>
470 Type sum(const FieldField<Field, Type>& f)
471 {
472  if (f.size())
473  {
474  Type Sum = pTraits<Type>::zero;
475 
476  forAll(f, i)
477  {
478  Sum += sum(f[i]);
479  }
480 
481  return Sum;
482  }
483  else
484  {
485  return pTraits<Type>::zero;
486  }
487 }
488 
490 
491 template<template<class> class Field, class Type>
492 scalar sumMag(const FieldField<Field, Type>& f)
493 {
494  if (f.size())
495  {
496  scalar SumMag = 0.0;
497 
498  forAll(f, i)
499  {
500  SumMag += sumMag(f[i]);
501  }
502 
503  return SumMag;
504  }
505  else
506  {
507  return 0.0;
508  }
509 }
510 
512 
513 template<template<class> class Field, class Type>
514 Type average(const FieldField<Field, Type>& f)
515 {
516  if (f.size())
517  {
518  label n = 0;
519 
520  forAll(f, i)
521  {
522  n += f[i].size();
523  }
524 
525  if (n == 0)
526  {
527  WarningIn("average(const FieldField<Field, Type>&) const")
528  << "empty fieldField, returning zero" << endl;
529 
530  return pTraits<Type>::zero;
531  }
532 
533  Type avrg = sum(f)/n;
534 
535  return avrg;
536  }
537  else
538  {
539  WarningIn("average(const FieldField<Field, Type>&) const")
540  << "empty fieldField, returning zero" << endl;
541 
542  return pTraits<Type>::zero;
543  }
544 }
545 
547 
548 
550 
551 #define G_UNARY_FUNCTION(returnType, gFunc, func, rFunc) \
552  \
553 template<template<class> class Field, class Type> \
554 returnType gFunc(const FieldField<Field, Type>& f) \
555 { \
556  returnType res = func(f); \
557  reduce(res, rFunc##Op<Type>()); \
558  return res; \
559 } \
560 TMP_UNARY_FUNCTION(returnType, gFunc)
561 
566 
567 #undef G_UNARY_FUNCTION
568 
569 
570 template<template<class> class Field, class Type>
572 {
573  label n = 0;
574 
575  forAll(f, i)
576  {
577  n += f[i].size();
578  }
579 
580  reduce(n, sumOp<label>());
581 
582  if (n > 0)
583  {
584  Type avrg = gSum(f)/n;
585 
586  return avrg;
587  }
588  else
589  {
590  WarningIn("gAverage(const FieldField<Field, Type>&) const")
591  << "empty fieldField, returning zero" << endl;
592 
593  return pTraits<Type>::zero;
594  }
595 }
596 
598 
599 #undef TMP_UNARY_FUNCTION
600 
601 
602 BINARY_FUNCTION(Type, Type, Type, max)
603 BINARY_FUNCTION(Type, Type, Type, min)
604 BINARY_FUNCTION(Type, Type, Type, cmptMultiply)
605 BINARY_FUNCTION(Type, Type, Type, cmptDivide)
606 
607 BINARY_TYPE_FUNCTION(Type, Type, Type, max)
608 BINARY_TYPE_FUNCTION(Type, Type, Type, min)
609 BINARY_TYPE_FUNCTION(Type, Type, Type, cmptMultiply)
610 BINARY_TYPE_FUNCTION(Type, Type, Type, cmptDivide)
611 
612 
613 /* * * * * * * * * * * * * * * * Global operators * * * * * * * * * * * * * */
614 
615 UNARY_OPERATOR(Type, Type, -, negate)
616 
617 #ifndef __INTEL_COMPILER
618 BINARY_OPERATOR(Type, Type, scalar, *, multiply)
619 BINARY_OPERATOR(Type, scalar, Type, *, multiply)
620 #endif
621 BINARY_OPERATOR(Type, Type, scalar, /, divide)
622 
623 BINARY_TYPE_OPERATOR_SF(Type, scalar, Type, *, multiply)
624 BINARY_TYPE_OPERATOR_FS(Type, Type, scalar, *, multiply)
625 
626 BINARY_TYPE_OPERATOR_FS(Type, Type, scalar, /, divide)
627 
628 
629 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
630 
631 #define PRODUCT_OPERATOR(product, op, opFunc) \
632  \
633 template<template<class> class Field, class Type1, class Type2> \
634 void opFunc \
635 ( \
636  FieldField<Field, typename product<Type1, Type2>::type>& f, \
637  const FieldField<Field, Type1>& f1, \
638  const FieldField<Field, Type2>& f2 \
639 ) \
640 { \
641  forAll(f, i) \
642  { \
643  opFunc(f[i], f1[i], f2[i]); \
644  } \
645 } \
646  \
647 template<template<class> class Field, class Type1, class Type2> \
648 tmp<FieldField<Field, typename product<Type1, Type2>::type> > \
649 operator op \
650 ( \
651  const FieldField<Field, Type1>& f1, \
652  const FieldField<Field, Type2>& f2 \
653 ) \
654 { \
655  typedef typename product<Type1, Type2>::type productType; \
656  tmp<FieldField<Field, productType> > tRes \
657  ( \
658  FieldField<Field, productType>::NewCalculatedType(f1) \
659  ); \
660  opFunc(tRes(), f1, f2); \
661  return tRes; \
662 } \
663  \
664 template<template<class> class Field, class Type1, class Type2> \
665 tmp<FieldField<Field, typename product<Type1, Type2>::type> > \
666 operator op \
667 ( \
668  const FieldField<Field, Type1>& f1, \
669  const tmp<FieldField<Field, Type2> >& tf2 \
670 ) \
671 { \
672  typedef typename product<Type1, Type2>::type productType; \
673  tmp<FieldField<Field, productType> > tRes \
674  ( \
675  reuseTmpFieldField<Field, productType, Type2>::New(tf2) \
676  ); \
677  opFunc(tRes(), f1, tf2()); \
678  reuseTmpFieldField<Field, productType, Type2>::clear(tf2); \
679  return tRes; \
680 } \
681  \
682 template<template<class> class Field, class Type1, class Type2> \
683 tmp<FieldField<Field, typename product<Type1, Type2>::type> > \
684 operator op \
685 ( \
686  const tmp<FieldField<Field, Type1> >& tf1, \
687  const FieldField<Field, Type2>& f2 \
688 ) \
689 { \
690  typedef typename product<Type1, Type2>::type productType; \
691  tmp<FieldField<Field, productType> > tRes \
692  ( \
693  reuseTmpFieldField<Field, productType, Type1>::New(tf1) \
694  ); \
695  opFunc(tRes(), tf1(), f2); \
696  reuseTmpFieldField<Field, productType, Type1>::clear(tf1); \
697  return tRes; \
698 } \
699  \
700 template<template<class> class Field, class Type1, class Type2> \
701 tmp<FieldField<Field, typename product<Type1, Type2>::type> > \
702 operator op \
703 ( \
704  const tmp<FieldField<Field, Type1> >& tf1, \
705  const tmp<FieldField<Field, Type2> >& tf2 \
706 ) \
707 { \
708  typedef typename product<Type1, Type2>::type productType; \
709  tmp<FieldField<Field, productType> > tRes \
710  ( \
711  reuseTmpTmpFieldField<Field, productType, Type1, Type1, Type2>::New \
712  (tf1, tf2) \
713  ); \
714  opFunc(tRes(), tf1(), tf2()); \
715  reuseTmpTmpFieldField<Field, productType, Type1, Type1, Type2>::clear \
716  (tf1, tf2); \
717  return tRes; \
718 } \
719  \
720 template \
721 <template<class> class Field, class Type, class Form, class Cmpt, int nCmpt> \
722 void opFunc \
723 ( \
724  FieldField<Field, typename product<Type, Form>::type>& f, \
725  const FieldField<Field, Type>& f1, \
726  const VectorSpace<Form,Cmpt,nCmpt>& vs \
727 ) \
728 { \
729  forAll(f, i) \
730  { \
731  opFunc(f[i], f1[i], vs); \
732  } \
733 } \
734  \
735 template \
736 <template<class> class Field, class Type, class Form, class Cmpt, int nCmpt> \
737 tmp<FieldField<Field, typename product<Type, Form>::type> > \
738 operator op \
739 ( \
740  const FieldField<Field, Type>& f1, \
741  const VectorSpace<Form,Cmpt,nCmpt>& vs \
742 ) \
743 { \
744  typedef typename product<Type, Form>::type productType; \
745  tmp<FieldField<Field, productType> > tRes \
746  ( \
747  FieldField<Field, productType>::NewCalculatedType(f1) \
748  ); \
749  opFunc(tRes(), f1, static_cast<const Form&>(vs)); \
750  return tRes; \
751 } \
752  \
753 template \
754 <template<class> class Field, class Type, class Form, class Cmpt, int nCmpt> \
755 tmp<FieldField<Field, typename product<Type, Form>::type> > \
756 operator op \
757 ( \
758  const tmp<FieldField<Field, Type> >& tf1, \
759  const VectorSpace<Form,Cmpt,nCmpt>& vs \
760 ) \
761 { \
762  typedef typename product<Type, Form>::type productType; \
763  tmp<FieldField<Field, productType> > tRes \
764  ( \
765  reuseTmpFieldField<Field, productType, Type>::New(tf1) \
766  ); \
767  opFunc(tRes(), tf1(), static_cast<const Form&>(vs)); \
768  reuseTmpFieldField<Field, productType, Type>::clear(tf1); \
769  return tRes; \
770 } \
771  \
772 template \
773 <template<class> class Field, class Form, class Cmpt, int nCmpt, class Type> \
774 void opFunc \
775 ( \
776  FieldField<Field, typename product<Form, Type>::type>& f, \
777  const VectorSpace<Form,Cmpt,nCmpt>& vs, \
778  const FieldField<Field, Type>& f1 \
779 ) \
780 { \
781  forAll(f, i) \
782  { \
783  opFunc(f[i], vs, f1[i]); \
784  } \
785 } \
786  \
787 template \
788 <template<class> class Field, class Form, class Cmpt, int nCmpt, class Type> \
789 tmp<FieldField<Field, typename product<Form, Type>::type> > \
790 operator op \
791 ( \
792  const VectorSpace<Form,Cmpt,nCmpt>& vs, \
793  const FieldField<Field, Type>& f1 \
794 ) \
795 { \
796  typedef typename product<Form, Type>::type productType; \
797  tmp<FieldField<Field, productType> > tRes \
798  ( \
799  FieldField<Field, productType>::NewCalculatedType(f1) \
800  ); \
801  opFunc(tRes(), static_cast<const Form&>(vs), f1); \
802  return tRes; \
803 } \
804  \
805 template \
806 <template<class> class Field, class Form, class Cmpt, int nCmpt, class Type> \
807 tmp<FieldField<Field, typename product<Form, Type>::type> > \
808 operator op \
809 ( \
810  const VectorSpace<Form,Cmpt,nCmpt>& vs, \
811  const tmp<FieldField<Field, Type> >& tf1 \
812 ) \
813 { \
814  typedef typename product<Form, Type>::type productType; \
815  tmp<FieldField<Field, productType> > tRes \
816  ( \
817  reuseTmpFieldField<Field, productType, Type>::New(tf1) \
818  ); \
819  opFunc(tRes(), static_cast<const Form&>(vs), tf1()); \
820  reuseTmpFieldField<Field, productType, Type>::clear(tf1); \
821  return tRes; \
822 }
823 
826 
831 
832 #undef PRODUCT_OPERATOR
833 
834 
835 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
836 
837 } // End namespace Foam
838 
839 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
840 
842 
843 // ************************ vim: set sw=4 sts=4 et: ************************ //