GeometricFieldFunctions.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-2024 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 "GeometricFieldReuseFunctions.H"
27 
28 #define TEMPLATE \
29  template \
30  < \
31  class Type, \
32  class GeoMesh, \
33  template<class> class PrimitiveField \
34  >
35 #define TEMPLATE2 \
36  template \
37  < \
38  class Type, \
39  class GeoMesh, \
40  template<class> class PrimitiveField1, \
41  template<class> class PrimitiveField2 \
42  >
43 #define TEMPLATE3 \
44  template \
45  < \
46  class Type, \
47  class GeoMesh, \
48  template<class> class PrimitiveField1, \
49  template<class> class PrimitiveField2, \
50  template<class> class PrimitiveField3 \
51  >
52 #include "GeometricFieldFunctionsM.C"
53 
54 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
55 
56 namespace Foam
57 {
58 
59 // * * * * * * * * * * * * * * * Global functions * * * * * * * * * * * * * //
60 
61 TEMPLATE2
62 void component
63 (
64  GeometricField
65  <
66  typename GeometricField<Type, GeoMesh, PrimitiveField1>::cmptType,
67  GeoMesh,
68  PrimitiveField1
69  >& gcf,
70  const GeometricField<Type, GeoMesh, PrimitiveField2>& gf,
71  const direction d
72 )
73 {
74  component(gcf.primitiveFieldRef(), gf.primitiveField(), d);
75  component(gcf.boundaryFieldRef(), gf.boundaryField(), d);
76 }
77 
78 
79 TEMPLATE2
80 void T
81 (
82  GeometricField<Type, GeoMesh, PrimitiveField1>& gf,
83  const GeometricField<Type, GeoMesh, PrimitiveField2>& gf1
84 )
85 {
86  T(gf.primitiveFieldRef(), gf1.primitiveField());
87  T(gf.boundaryFieldRef(), gf1.boundaryField());
88 }
89 
90 
91 template
92 <
93  class Type,
94  class GeoMesh,
95  template<class> class PrimitiveField1,
96  template<class> class PrimitiveField2,
97  direction r
98 >
99 void pow
100 (
101  GeometricField
102  <
103  typename powProduct<Type, r>::type,
104  GeoMesh,
105  PrimitiveField1
106  >& gf,
107  const GeometricField<Type, GeoMesh, PrimitiveField2>& gf1
108 )
109 {
110  pow(gf.primitiveFieldRef(), gf1.primitiveField(), r);
111  pow(gf.boundaryFieldRef(), gf1.boundaryField(), r);
112 }
113 
114 
115 template
116 <
117  class Type,
118  class GeoMesh,
119  template<class> class PrimitiveField,
120  direction r
121 >
122 tmp<GeometricField<typename powProduct<Type, r>::type, GeoMesh, Field>>
123 pow
124 (
125  const GeometricField<Type, GeoMesh, PrimitiveField>& gf,
126  typename powProduct<Type, r>::type
127 )
128 {
129  typedef typename powProduct<Type, r>::type powProductType;
130 
131  tmp<GeometricField<powProductType, GeoMesh, Field>> tPow
132  (
133  GeometricField<powProductType, GeoMesh, Field>::New
134  (
135  "pow(" + gf.name() + ',' + name(r) + ')',
136  gf.mesh(),
137  pow(gf.dimensions(), r)
138  )
139  );
140 
141  pow<Type, GeoMesh, Field, PrimitiveField, r>(tPow.ref(), gf);
142 
143  return tPow;
144 }
145 
146 
147 template
148 <
149  class Type,
150  class GeoMesh,
151  template<class> class PrimitiveField,
152  direction r
153 >
154 tmp<GeometricField<typename powProduct<Type, r>::type, GeoMesh, Field>>
155 pow
156 (
157  const tmp<GeometricField<Type, GeoMesh, PrimitiveField>>& tgf,
158  typename powProduct<Type, r>::type
159 )
160 {
161  typedef typename powProduct<Type, r>::type powProductType;
162 
163  const GeometricField<Type, GeoMesh, PrimitiveField>& gf = tgf();
164 
165  tmp<GeometricField<powProductType, GeoMesh, Field>> tPow
166  (
167  GeometricField<powProductType, GeoMesh, Field>::New
168  (
169  "pow(" + gf.name() + ',' + name(r) + ')',
170  gf.mesh(),
171  pow(gf.dimensions(), r)
172  )
173  );
174 
175  pow<Type, GeoMesh, Field, PrimitiveField, r>
176  (
177  tPow.ref(),
178  gf
179  );
180 
181  tgf.clear();
182 
183  return tPow;
184 }
185 
186 
187 TEMPLATE2
188 void sqr
189 (
190  GeometricField
191  <
192  typename outerProduct<Type, Type>::type,
193  GeoMesh,
194  PrimitiveField1
195  >& gf,
196  const GeometricField<Type, GeoMesh, PrimitiveField2>& gf1
197 )
198 {
199  sqr(gf.primitiveFieldRef(), gf1.primitiveField());
200  sqr(gf.boundaryFieldRef(), gf1.boundaryField());
201 }
202 
203 
204 TEMPLATE
205 tmp<GeometricField<typename outerProduct<Type, Type>::type, GeoMesh, Field>>
206 sqr(const GeometricField<Type, GeoMesh, PrimitiveField>& gf)
207 {
208  typedef typename outerProduct<Type, Type>::type outerProductType;
209 
210  tmp<GeometricField<outerProductType, GeoMesh, Field>> tSqr
211  (
212  GeometricField<outerProductType, GeoMesh, Field>::New
213  (
214  "sqr(" + gf.name() + ')',
215  gf.mesh(),
216  sqr(gf.dimensions())
217  )
218  );
219 
220  sqr(tSqr.ref(), gf);
221 
222  return tSqr;
223 }
224 
225 
226 TEMPLATE
227 tmp<GeometricField<typename outerProduct<Type, Type>::type, GeoMesh, Field>>
228 sqr(const tmp<GeometricField<Type, GeoMesh, PrimitiveField>>& tgf)
229 {
230  typedef typename outerProduct<Type, Type>::type outerProductType;
231 
232  const GeometricField<Type, GeoMesh, PrimitiveField>& gf = tgf();
233 
234  tmp<GeometricField<outerProductType, GeoMesh, Field>> tSqr
235  (
236  GeometricField<outerProductType, GeoMesh, Field>::New
237  (
238  "sqr(" + gf.name() + ')',
239  gf.mesh(),
240  sqr(gf.dimensions())
241  )
242  );
243 
244  sqr(tSqr.ref(), gf);
245 
246  tgf.clear();
247 
248  return tSqr;
249 }
250 
251 
252 TEMPLATE2
253 void magSqr
254 (
255  GeometricField<scalar, GeoMesh, PrimitiveField1>& gsf,
256  const GeometricField<Type, GeoMesh, PrimitiveField2>& gf
257 )
258 {
259  magSqr(gsf.primitiveFieldRef(), gf.primitiveField());
260  magSqr(gsf.boundaryFieldRef(), gf.boundaryField());
261 }
262 
263 
264 TEMPLATE
265 tmp<GeometricField<scalar, GeoMesh, Field>> magSqr
266 (
267  const GeometricField<Type, GeoMesh, PrimitiveField>& gf
268 )
269 {
270  tmp<GeometricField<scalar, GeoMesh, Field>> tMagSqr
271  (
272  GeometricField<scalar, GeoMesh, Field>::New
273  (
274  "magSqr(" + gf.name() + ')',
275  gf.mesh(),
276  sqr(gf.dimensions())
277  )
278  );
279 
280  magSqr(tMagSqr.ref(), gf);
281 
282  return tMagSqr;
283 }
284 
285 
286 TEMPLATE
287 tmp<GeometricField<scalar, GeoMesh, Field>> magSqr
288 (
289  const tmp<GeometricField<Type, GeoMesh, PrimitiveField>>& tgf
290 )
291 {
292  const GeometricField<Type, GeoMesh, PrimitiveField>& gf = tgf();
293 
294  tmp<GeometricField<scalar, GeoMesh, Field>> tMagSqr
295  (
296  GeometricField<scalar, GeoMesh, Field>::New
297  (
298  "magSqr(" + gf.name() + ')',
299  gf.mesh(),
300  sqr(gf.dimensions())
301  )
302  );
303 
304  magSqr(tMagSqr.ref(), gf);
305 
306  tgf.clear();
307 
308  return tMagSqr;
309 }
310 
311 
312 TEMPLATE2
313 void mag
314 (
315  GeometricField<scalar, GeoMesh, PrimitiveField1>& gsf,
316  const GeometricField<Type, GeoMesh, PrimitiveField2>& gf
317 )
318 {
319  mag(gsf.primitiveFieldRef(), gf.primitiveField());
320  mag(gsf.boundaryFieldRef(), gf.boundaryField());
321 }
322 
323 
324 TEMPLATE
325 tmp<GeometricField<scalar, GeoMesh, Field>> mag
326 (
327  const GeometricField<Type, GeoMesh, PrimitiveField>& gf
328 )
329 {
330  tmp<GeometricField<scalar, GeoMesh, Field>> tMag
331  (
332  GeometricField<scalar, GeoMesh, Field>::New
333  (
334  "mag(" + gf.name() + ')',
335  gf.mesh(),
336  gf.dimensions()
337  )
338  );
339 
340  mag(tMag.ref(), gf);
341 
342  return tMag;
343 }
344 
345 
346 TEMPLATE
347 tmp<GeometricField<scalar, GeoMesh, Field>> mag
348 (
349  const tmp<GeometricField<Type, GeoMesh, PrimitiveField>>& tgf
350 )
351 {
352  const GeometricField<Type, GeoMesh, PrimitiveField>& gf = tgf();
353 
354  tmp<GeometricField<scalar, GeoMesh, Field>> tMag
355  (
356  GeometricField<scalar, GeoMesh, Field>::New
357  (
358  "mag(" + gf.name() + ')',
359  gf.mesh(),
360  gf.dimensions()
361  )
362  );
363 
364  mag(tMag.ref(), gf);
365 
366  tgf.clear();
367 
368  return tMag;
369 }
370 
371 
372 TEMPLATE2
373 void cmptAv
374 (
375  GeometricField
376  <
377  typename GeometricField<Type, GeoMesh, PrimitiveField1>::cmptType,
378  GeoMesh,
379  PrimitiveField1
380  >& gcf,
381  const GeometricField<Type, GeoMesh, PrimitiveField2>& gf
382 )
383 {
384  cmptAv(gcf.primitiveFieldRef(), gf.primitiveField());
385  cmptAv(gcf.boundaryFieldRef(), gf.boundaryField());
386 }
387 
388 
389 TEMPLATE
390 tmp
391 <
392  GeometricField
393  <
394  typename GeometricField<Type, GeoMesh, PrimitiveField>::cmptType,
395  GeoMesh,
396  Field
397  >
398 >
399 cmptAv(const GeometricField<Type, GeoMesh, PrimitiveField>& gf)
400 {
401  typedef typename
402  GeometricField<Type, GeoMesh, PrimitiveField>::cmptType cmptType;
403 
404  tmp<GeometricField<cmptType, GeoMesh, Field>> CmptAv
405  (
406  GeometricField<scalar, GeoMesh, Field>::New
407  (
408  "cmptAv(" + gf.name() + ')',
409  gf.mesh(),
410  gf.dimensions()
411  )
412  );
413 
414  cmptAv(CmptAv.ref(), gf);
415 
416  return CmptAv;
417 }
418 
419 
420 TEMPLATE
421 tmp
422 <
423  GeometricField
424  <
425  typename GeometricField<Type, GeoMesh, PrimitiveField>::cmptType,
426  GeoMesh,
427  Field
428  >
429 >
430 cmptAv(const tmp<GeometricField<Type, GeoMesh, PrimitiveField>>& tgf)
431 {
432  typedef typename
433  GeometricField<Type, GeoMesh, PrimitiveField>::cmptType cmptType;
434 
435  const GeometricField<Type, GeoMesh, PrimitiveField>& gf = tgf();
436 
437  tmp<GeometricField<cmptType, GeoMesh, Field>> CmptAv
438  (
439  GeometricField<scalar, GeoMesh, Field>::New
440  (
441  "cmptAv(" + gf.name() + ')',
442  gf.mesh(),
443  gf.dimensions()
444  )
445  );
446 
447  cmptAv(CmptAv.ref(), gf);
448 
449  tgf.clear();
450 
451  return CmptAv;
452 }
453 
454 UNARY_FUNCTION(Type, Type, cmptMag, cmptMag);
455 
456 
457 #define UNARY_REDUCTION_FUNCTION_WITH_BOUNDARY(returnType, func, gFunc) \
458  \
459 TEMPLATE \
460 dimensioned<returnType> func \
461 ( \
462  const GeometricField<Type, GeoMesh, PrimitiveField>& gf \
463 ) \
464 { \
465  return dimensioned<Type> \
466  ( \
467  #func "(" + gf.name() + ')', \
468  gf.dimensions(), \
469  Foam::func(gFunc(gf.primitiveField()), gFunc(gf.boundaryField())) \
470  ); \
471 } \
472  \
473 TEMPLATE \
474 dimensioned<returnType> func \
475 ( \
476  const tmp<GeometricField<Type, GeoMesh, PrimitiveField>>& tgf1 \
477 ) \
478 { \
479  dimensioned<returnType> res = func(tgf1()); \
480  tgf1.clear(); \
481  return res; \
482 }
483 
484 UNARY_REDUCTION_FUNCTION_WITH_BOUNDARY(Type, max, gMax)
485 UNARY_REDUCTION_FUNCTION_WITH_BOUNDARY(Type, min, gMin)
486 
487 #undef UNARY_REDUCTION_FUNCTION_WITH_BOUNDARY
488 
489 
490 #define UNARY_REDUCTION_FUNCTION(returnType, func, gFunc) \
491  \
492 TEMPLATE \
493 dimensioned<returnType> func \
494 ( \
495  const GeometricField<Type, GeoMesh, PrimitiveField>& gf \
496 ) \
497 { \
498  return dimensioned<Type> \
499  ( \
500  #func "(" + gf.name() + ')', \
501  gf.dimensions(), \
502  gFunc(gf.primitiveField()) \
503  ); \
504 } \
505  \
506 TEMPLATE \
507 dimensioned<returnType> func \
508 ( \
509  const tmp<GeometricField<Type, GeoMesh, PrimitiveField>>& tgf1 \
510 ) \
511 { \
512  dimensioned<returnType> res = func(tgf1()); \
513  tgf1.clear(); \
514  return res; \
515 }
516 
517 UNARY_REDUCTION_FUNCTION(Type, sum, gSum)
518 UNARY_REDUCTION_FUNCTION(scalar, sumMag, gSumMag)
519 UNARY_REDUCTION_FUNCTION(Type, average, gAverage)
520 
521 #undef UNARY_REDUCTION_FUNCTION
522 
523 
524 BINARY_FUNCTION(Type, Type, Type, max)
525 BINARY_FUNCTION(Type, Type, Type, min)
526 BINARY_FUNCTION(Type, Type, Type, cmptMultiply)
527 BINARY_FUNCTION(Type, Type, Type, cmptDivide)
528 
529 BINARY_TYPE_FUNCTION(Type, Type, Type, max)
530 BINARY_TYPE_FUNCTION(Type, Type, Type, min)
531 BINARY_TYPE_FUNCTION(Type, Type, Type, cmptMultiply)
532 BINARY_TYPE_FUNCTION(Type, Type, Type, cmptDivide)
533 
534 
535 // * * * * * * * * * * * * * * * Global operators * * * * * * * * * * * * * //
536 
537 UNARY_OPERATOR(Type, Type, -, negate, transform)
538 
539 BINARY_OPERATOR(Type, Type, scalar, *, '*', multiply)
540 BINARY_OPERATOR(Type, scalar, Type, *, '*', multiply)
541 BINARY_OPERATOR(Type, Type, scalar, /, '|', divide)
542 
543 BINARY_TYPE_OPERATOR_SF(Type, scalar, Type, *, '*', multiply)
544 BINARY_TYPE_OPERATOR_FS(Type, Type, scalar, *, '*', multiply)
545 
546 BINARY_TYPE_OPERATOR_FS(Type, Type, scalar, /, '|', divide)
547 
548 
549 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
550 
551 #define PRODUCT_OPERATOR(product, op, opFunc) \
552  \
553 template \
554 < \
555  class Type1, \
556  class Type2, \
557  class GeoMesh, \
558  template<class> class PrimitiveField1, \
559  template<class> class PrimitiveField2, \
560  template<class> class PrimitiveField3 \
561 > \
562 void opFunc \
563 ( \
564  GeometricField \
565  < \
566  typename product<Type1, Type2>::type, \
567  GeoMesh, \
568  PrimitiveField1 \
569  >& gf, \
570  const GeometricField<Type1, GeoMesh, PrimitiveField2>& gf1, \
571  const GeometricField<Type2, GeoMesh, PrimitiveField3>& gf2 \
572 ) \
573 { \
574  Foam::opFunc \
575  ( \
576  gf.primitiveFieldRef(), \
577  gf1.primitiveField(), \
578  gf2.primitiveField() \
579  ); \
580  Foam::opFunc \
581  ( \
582  gf.boundaryFieldRef(), \
583  gf1.boundaryField(), \
584  gf2.boundaryField() \
585  ); \
586 } \
587  \
588 template \
589 < \
590  class Type1, \
591  class Type2, \
592  class GeoMesh, \
593  template<class> class PrimitiveField1, \
594  template<class> class PrimitiveField2 \
595 > \
596 tmp<GeometricField<typename product<Type1, Type2>::type, GeoMesh, Field>> \
597 operator op \
598 ( \
599  const GeometricField<Type1, GeoMesh, PrimitiveField1>& gf1, \
600  const GeometricField<Type2, GeoMesh, PrimitiveField2>& gf2 \
601 ) \
602 { \
603  typedef typename product<Type1, Type2>::type productType; \
604  \
605  tmp<GeometricField<productType, GeoMesh, Field>> tRes \
606  ( \
607  GeometricField<productType, GeoMesh, Field>::New \
608  ( \
609  '(' + gf1.name() + #op + gf2.name() + ')', \
610  gf1.mesh(), \
611  gf1.dimensions() op gf2.dimensions() \
612  ) \
613  ); \
614  \
615  Foam::opFunc(tRes.ref(), gf1, gf2); \
616  \
617  return tRes; \
618 } \
619  \
620 template \
621 < \
622  class Type1, \
623  class Type2, \
624  class GeoMesh, \
625  template<class> class PrimitiveField1, \
626  template<class> class PrimitiveField2 \
627 > \
628 tmp<GeometricField<typename product<Type1, Type2>::type, GeoMesh, Field>> \
629 operator op \
630 ( \
631  const GeometricField<Type1, GeoMesh, PrimitiveField1>& gf1, \
632  const tmp<GeometricField<Type2, GeoMesh, PrimitiveField2>>& tgf2 \
633 ) \
634 { \
635  typedef typename product<Type1, Type2>::type productType; \
636  \
637  const GeometricField<Type2, GeoMesh, PrimitiveField2>& gf2 = tgf2(); \
638  \
639  tmp<GeometricField<productType, GeoMesh, Field>> tRes \
640  ( \
641  reuseTmpGeometricField \
642  <productType, Type2, GeoMesh, PrimitiveField2>::New \
643  ( \
644  tgf2, \
645  '(' + gf1.name() + #op + gf2.name() + ')', \
646  gf1.dimensions() op gf2.dimensions() \
647  ) \
648  ); \
649  \
650  Foam::opFunc(tRes.ref(), gf1, gf2); \
651  \
652  tgf2.clear(); \
653  \
654  return tRes; \
655 } \
656  \
657 template \
658 < \
659  class Type1, \
660  class Type2, \
661  class GeoMesh, \
662  template<class> class PrimitiveField1, \
663  template<class> class PrimitiveField2 \
664 > \
665 tmp<GeometricField<typename product<Type1, Type2>::type, GeoMesh, Field>> \
666 operator op \
667 ( \
668  const tmp<GeometricField<Type1, GeoMesh, PrimitiveField1>>& tgf1, \
669  const GeometricField<Type2, GeoMesh, PrimitiveField2>& gf2 \
670 ) \
671 { \
672  typedef typename product<Type1, Type2>::type productType; \
673  \
674  const GeometricField<Type1, GeoMesh, PrimitiveField1>& gf1 = tgf1(); \
675  \
676  tmp<GeometricField<productType, GeoMesh, Field>> tRes \
677  ( \
678  reuseTmpGeometricField \
679  <productType, Type1, GeoMesh, PrimitiveField1>::New \
680  ( \
681  tgf1, \
682  '(' + gf1.name() + #op + gf2.name() + ')', \
683  gf1.dimensions() op gf2.dimensions() \
684  ) \
685  ); \
686  \
687  Foam::opFunc(tRes.ref(), gf1, gf2); \
688  \
689  tgf1.clear(); \
690  \
691  return tRes; \
692 } \
693  \
694 template \
695 < \
696  class Type1, \
697  class Type2, \
698  class GeoMesh, \
699  template<class> class PrimitiveField1, \
700  template<class> class PrimitiveField2 \
701 > \
702 tmp<GeometricField<typename product<Type1, Type2>::type, GeoMesh, Field>> \
703 operator op \
704 ( \
705  const tmp<GeometricField<Type1, GeoMesh, PrimitiveField1>>& tgf1, \
706  const tmp<GeometricField<Type2, GeoMesh, PrimitiveField2>>& tgf2 \
707 ) \
708 { \
709  typedef typename product<Type1, Type2>::type productType; \
710  \
711  const GeometricField<Type1, GeoMesh, PrimitiveField1>& gf1 = tgf1(); \
712  const GeometricField<Type2, GeoMesh, PrimitiveField2>& gf2 = tgf2(); \
713  \
714  tmp<GeometricField<productType, GeoMesh, Field>> tRes \
715  ( \
716  reuseTmpTmpGeometricField \
717  < \
718  productType, \
719  Type1, \
720  Type2, \
721  GeoMesh, \
722  PrimitiveField1, \
723  PrimitiveField2 \
724  >::New \
725  ( \
726  tgf1, \
727  tgf2, \
728  '(' + gf1.name() + #op + gf2.name() + ')', \
729  gf1.dimensions() op gf2.dimensions() \
730  ) \
731  ); \
732  \
733  Foam::opFunc(tRes.ref(), gf1, gf2); \
734  \
735  tgf1.clear(); \
736  tgf2.clear(); \
737  \
738  return tRes; \
739 } \
740  \
741  \
742 template \
743 < \
744  class Form, \
745  class Type, \
746  class GeoMesh, \
747  template<class> class PrimitiveField1, \
748  template<class> class PrimitiveField2 \
749 > \
750 void opFunc \
751 ( \
752  GeometricField \
753  < \
754  typename product<Type, Form>::type, \
755  GeoMesh, \
756  PrimitiveField1 \
757  >& gf, \
758  const GeometricField<Type, GeoMesh, PrimitiveField2>& gf1, \
759  const dimensioned<Form>& dvs \
760 ) \
761 { \
762  Foam::opFunc(gf.primitiveFieldRef(), gf1.primitiveField(), dvs.value()); \
763  Foam::opFunc(gf.boundaryFieldRef(), gf1.boundaryField(), dvs.value()); \
764 } \
765  \
766 template \
767 < \
768  class Form, \
769  class Type, \
770  class GeoMesh, \
771  template<class> class PrimitiveField \
772 > \
773 tmp<GeometricField<typename product<Form, Type>::type, GeoMesh, Field>> \
774 operator op \
775 ( \
776  const GeometricField<Type, GeoMesh, PrimitiveField>& gf1, \
777  const dimensioned<Form>& dvs \
778 ) \
779 { \
780  typedef typename product<Type, Form>::type productType; \
781  \
782  tmp<GeometricField<productType, GeoMesh, Field>> tRes \
783  ( \
784  GeometricField<productType, GeoMesh, Field>::New \
785  ( \
786  '(' + gf1.name() + #op + dvs.name() + ')', \
787  gf1.mesh(), \
788  gf1.dimensions() op dvs.dimensions() \
789  ) \
790  ); \
791  \
792  Foam::opFunc(tRes.ref(), gf1, dvs); \
793  \
794  return tRes; \
795 } \
796  \
797 template \
798 < \
799  class Form, \
800  class Cmpt, \
801  direction nCmpt, \
802  class Type, \
803  class GeoMesh, \
804  template<class> class PrimitiveField \
805 > \
806 tmp<GeometricField<typename product<Form, Type>::type, GeoMesh, Field>> \
807 operator op \
808 ( \
809  const GeometricField<Type, GeoMesh, PrimitiveField>& gf1, \
810  const VectorSpace<Form, Cmpt, nCmpt>& vs \
811 ) \
812 { \
813  return gf1 op dimensioned<Form>(static_cast<const Form&>(vs)); \
814 } \
815  \
816 template \
817 < \
818  class Form, \
819  class Type, \
820  class GeoMesh, \
821  template<class> class PrimitiveField \
822 > \
823 tmp<GeometricField<typename product<Type, Form>::type, GeoMesh, Field>> \
824 operator op \
825 ( \
826  const tmp<GeometricField<Type, GeoMesh, PrimitiveField>>& tgf1, \
827  const dimensioned<Form>& dvs \
828 ) \
829 { \
830  typedef typename product<Type, Form>::type productType; \
831  \
832  const GeometricField<Type, GeoMesh, PrimitiveField>& gf1 = tgf1(); \
833  \
834  tmp<GeometricField<productType, GeoMesh, Field>> tRes \
835  ( \
836  reuseTmpGeometricField \
837  <productType, Type, GeoMesh, PrimitiveField>::New \
838  ( \
839  tgf1, \
840  '(' + gf1.name() + #op + dvs.name() + ')', \
841  gf1.dimensions() op dvs.dimensions() \
842  ) \
843  ); \
844  \
845  Foam::opFunc(tRes.ref(), gf1, dvs); \
846  \
847  tgf1.clear(); \
848  \
849  return tRes; \
850 } \
851  \
852 template \
853 < \
854  class Form, \
855  class Cmpt, \
856  direction nCmpt, \
857  class Type, \
858  class GeoMesh, \
859  template<class> class PrimitiveField \
860 > \
861 tmp<GeometricField<typename product<Form, Type>::type, GeoMesh, Field>> \
862 operator op \
863 ( \
864  const tmp<GeometricField<Type, GeoMesh, PrimitiveField>>& tgf1, \
865  const VectorSpace<Form, Cmpt, nCmpt>& vs \
866 ) \
867 { \
868  return tgf1 op dimensioned<Form>(static_cast<const Form&>(vs)); \
869 } \
870  \
871  \
872 template \
873 < \
874  class Form, \
875  class Type, \
876  class GeoMesh, \
877  template<class> class PrimitiveField1, \
878  template<class> class PrimitiveField2 \
879 > \
880 void opFunc \
881 ( \
882  GeometricField \
883  < \
884  typename product<Form, Type>::type, \
885  GeoMesh, \
886  PrimitiveField1 \
887  >& gf, \
888  const dimensioned<Form>& dvs, \
889  const GeometricField<Type, GeoMesh, PrimitiveField2>& gf1 \
890 ) \
891 { \
892  Foam::opFunc(gf.primitiveFieldRef(), dvs.value(), gf1.primitiveField()); \
893  Foam::opFunc(gf.boundaryFieldRef(), dvs.value(), gf1.boundaryField()); \
894 } \
895  \
896 template \
897 < \
898  class Form, \
899  class Type, \
900  class GeoMesh, \
901  template<class> class PrimitiveField \
902 > \
903 tmp<GeometricField<typename product<Form, Type>::type, GeoMesh, Field>> \
904 operator op \
905 ( \
906  const dimensioned<Form>& dvs, \
907  const GeometricField<Type, GeoMesh, PrimitiveField>& gf1 \
908 ) \
909 { \
910  typedef typename product<Form, Type>::type productType; \
911  \
912  tmp<GeometricField<productType, GeoMesh, Field>> tRes \
913  ( \
914  GeometricField<productType, GeoMesh, Field>::New \
915  ( \
916  '(' + dvs.name() + #op + gf1.name() + ')', \
917  gf1.mesh(), \
918  dvs.dimensions() op gf1.dimensions() \
919  ) \
920  ); \
921  \
922  Foam::opFunc(tRes.ref(), dvs, gf1); \
923  \
924  return tRes; \
925 } \
926  \
927 template \
928 < \
929  class Form, \
930  class Cmpt, \
931  direction nCmpt, \
932  class Type, \
933  class GeoMesh, \
934  template<class> class PrimitiveField \
935 > \
936 tmp<GeometricField<typename product<Form, Type>::type, GeoMesh, Field>> \
937 operator op \
938 ( \
939  const VectorSpace<Form, Cmpt, nCmpt>& vs, \
940  const GeometricField<Type, GeoMesh, PrimitiveField>& gf1 \
941 ) \
942 { \
943  return dimensioned<Form>(static_cast<const Form&>(vs)) op gf1; \
944 } \
945  \
946 template \
947 < \
948  class Form, \
949  class Type, \
950  class GeoMesh, \
951  template<class> class PrimitiveField \
952 > \
953 tmp<GeometricField<typename product<Form, Type>::type, GeoMesh, Field>> \
954 operator op \
955 ( \
956  const dimensioned<Form>& dvs, \
957  const tmp<GeometricField<Type, GeoMesh, PrimitiveField>>& tgf1 \
958 ) \
959 { \
960  typedef typename product<Form, Type>::type productType; \
961  \
962  const GeometricField<Type, GeoMesh, PrimitiveField>& gf1 = tgf1(); \
963  \
964  tmp<GeometricField<productType, GeoMesh, Field>> tRes \
965  ( \
966  reuseTmpGeometricField \
967  <productType, Type, GeoMesh, PrimitiveField>::New \
968  ( \
969  tgf1, \
970  '(' + dvs.name() + #op + gf1.name() + ')', \
971  dvs.dimensions() op gf1.dimensions() \
972  ) \
973  ); \
974  \
975  Foam::opFunc(tRes.ref(), dvs, gf1); \
976  \
977  tgf1.clear(); \
978  \
979  return tRes; \
980 } \
981  \
982 template \
983 < \
984  class Form, \
985  class Cmpt, \
986  direction nCmpt, \
987  class Type, \
988  class GeoMesh, \
989  template<class> class PrimitiveField \
990 > \
991 tmp<GeometricField<typename product<Form, Type>::type, GeoMesh, Field>> \
992 operator op \
993 ( \
994  const VectorSpace<Form, Cmpt, nCmpt>& vs, \
995  const tmp<GeometricField<Type, GeoMesh, PrimitiveField>>& tgf1 \
996 ) \
997 { \
998  return dimensioned<Form>(static_cast<const Form&>(vs)) op tgf1; \
999 }
1000 
1001 PRODUCT_OPERATOR(typeOfSum, +, add)
1002 PRODUCT_OPERATOR(typeOfSum, -, subtract)
1003 
1004 PRODUCT_OPERATOR(outerProduct, *, outer)
1005 PRODUCT_OPERATOR(crossProduct, ^, cross)
1006 PRODUCT_OPERATOR(innerProduct, &, dot)
1007 PRODUCT_OPERATOR(scalarProduct, &&, dotdot)
1008 
1009 #undef PRODUCT_OPERATOR
1010 
1011 
1012 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
1013 
1014 } // End namespace Foam
1015 
1016 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
1017 
1018 #include "undefFieldFunctionsM.H"
1019 
1020 // ************************************************************************* //
BINARY_TYPE_FUNCTION
#define BINARY_TYPE_FUNCTION(ReturnType, Type1, Type2, Func)
Definition: DimensionedFieldFunctionsM.C:448
TEMPLATE2
#define TEMPLATE2
Definition: GeometricFieldFunctions.C:35
UNARY_REDUCTION_FUNCTION_WITH_BOUNDARY
#define UNARY_REDUCTION_FUNCTION_WITH_BOUNDARY(returnType, func, gFunc)
Definition: GeometricFieldFunctions.C:457
TEMPLATE
#define TEMPLATE
Definition: GeometricFieldFunctions.C:28
PRODUCT_OPERATOR
#define PRODUCT_OPERATOR(product, op, opFunc)
Definition: GeometricFieldFunctions.C:551
UNARY_REDUCTION_FUNCTION
#define UNARY_REDUCTION_FUNCTION(returnType, func, gFunc)
Definition: GeometricFieldFunctions.C:490
BINARY_TYPE_OPERATOR_FS
#define BINARY_TYPE_OPERATOR_FS(TYPE, op, opFunc)
Definition: LagrangianPatchFieldFunctions.H:179
BINARY_FUNCTION
#define BINARY_FUNCTION(func)
Definition: LagrangianPatchFieldFunctions.H:108
BINARY_OPERATOR
#define BINARY_OPERATOR(Template, Type, Type1, Type2, op, opFunc)
Definition: LagrangianPatchFieldFunctions.H:149
UNARY_OPERATOR
#define UNARY_OPERATOR(op, opFunc)
Definition: LagrangianPatchFieldFunctions.H:138
UNARY_FUNCTION
#define UNARY_FUNCTION(Template, Type, Type1, func)
Definition: LagrangianPatchFieldFunctions.H:49
BINARY_TYPE_OPERATOR_SF
#define BINARY_TYPE_OPERATOR_SF(TYPE, op, opFunc)
Definition: LagrangianPatchFieldFunctions.H:168
Foam::DimensionedField::dimensions
const dimensionSet & dimensions() const
Return dimensions.
Definition: DimensionedFieldI.H:48
Foam::DimensionedField::mesh
const Mesh & mesh() const
Return mesh.
Definition: DimensionedFieldI.H:40
Foam::GeoMesh
Generic mesh wrapper used by volMesh, surfaceMesh, pointMesh etc.
Definition: GeoMesh.H:47
Foam::GeometricField
Generic GeometricField class.
Definition: GeometricField.H:77
Foam::GeometricField::boundaryField
const Boundary & boundaryField() const
Return const-reference to the boundary field.
Definition: GeometricFieldI.H:59
Foam::GeometricField::primitiveFieldRef
Internal::FieldType & primitiveFieldRef()
Return a reference to the primitive field.
Definition: GeometricField.C:1387
Foam::GeometricField::cmptType
Field< Type >::cmptType cmptType
Component type of the elements of the field.
Definition: GeometricField.H:110
Foam::GeometricField::boundaryFieldRef
Boundary & boundaryFieldRef()
Return a reference to the boundary field.
Definition: GeometricField.C:1398
Foam::GeometricField::primitiveField
const Internal::FieldType & primitiveField() const
Return a const-reference to the primitive field.
Definition: GeometricFieldI.H:50
Foam::IOobject::name
const word & name() const
Return name.
Definition: IOobject.H:307
Foam::outerProduct::type
typeOfRank< typename pTraits< arg1 >::cmptType, direction(pTraits< arg1 >::rank)+direction(pTraits< arg2 >::rank) >::type type
Definition: products.H:90
Foam::powProduct::type
symmTypeOfRank< typename pTraits< arg1 >::cmptType, arg2 *direction(pTraits< arg1 >::rank) >::type type
Definition: products.H:136
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
Foam
Namespace for OpenFOAM.
Definition: atmBoundaryLayer.H:214
Foam::subtract
void subtract(LagrangianPatchField< typename typeOfSum< Type1, Type2 >::type > &f, const LagrangianPatchField< Type1 > &f1, const LagrangianPatchField< Type2 > &f2)
Definition: LagrangianPatchFieldFunctions.H:228
Foam::dot
void dot(LagrangianPatchField< typename innerProduct< Type1, Type2 >::type > &f, const LagrangianPatchField< Type1 > &f1, const LagrangianPatchField< Type2 > &f2)
Definition: LagrangianPatchFieldFunctions.H:231
Foam::negate
void negate(LagrangianPatchField< Type > &f, const LagrangianPatchField< Type > &f1)
Definition: LagrangianPatchFieldFunctions.H:144
Foam::cmptMultiply
void cmptMultiply(LagrangianPatchField< Type > &f, const LagrangianPatchField< Type > &f1, const LagrangianPatchField< Type > &f2)
Definition: LagrangianPatchFieldFunctions.H:130
Foam::gSum
Type gSum(const FieldField< Field, Type > &f)
Definition: FieldFieldFunctions.C:559
Foam::outer
void outer(LagrangianPatchField< typename outerProduct< Type1, Type2 >::type > &f, const LagrangianPatchField< Type1 > &f1, const LagrangianPatchField< Type2 > &f2)
Definition: LagrangianPatchFieldFunctions.H:229
Foam::divide
void divide(LagrangianPatchField< Type > &f, const LagrangianPatchField< Type > &f1, const LagrangianPatchField< scalar > &f2)
Definition: LagrangianPatchFieldFunctions.H:163
Foam::dotdot
void dotdot(LagrangianPatchField< typename scalarProduct< Type1, Type2 >::type > &f, const LagrangianPatchField< Type1 > &f1, const LagrangianPatchField< Type2 > &f2)
Definition: LagrangianPatchFieldFunctions.H:232
Foam::gSumMag
scalar gSumMag(const FieldField< Field, Type > &f)
Definition: FieldFieldFunctions.C:560
Foam::cmptDivide
void cmptDivide(LagrangianPatchField< Type > &f, const LagrangianPatchField< Type > &f1, const LagrangianPatchField< Type > &f2)
Definition: LagrangianPatchFieldFunctions.H:131
Foam::T
void T(LagrangianPatchField< Type > &f, const LagrangianPatchField< Type > &f1)
Definition: LagrangianPatchFieldFunctions.H:90
Foam::average
dimensioned< Type > average(const DimensionedField< Type, GeoMesh, PrimitiveField > &df)
Definition: DimensionedFieldFunctions.C:377
Foam::sumMag
dimensioned< scalar > sumMag(const DimensionedField< Type, GeoMesh, PrimitiveField > &df)
Definition: DimensionedFieldFunctions.C:376
Foam::cross
void cross(LagrangianPatchField< typename crossProduct< Type1, Type2 >::type > &f, const LagrangianPatchField< Type1 > &f1, const LagrangianPatchField< Type2 > &f2)
Definition: LagrangianPatchFieldFunctions.H:230
Foam::mag
void mag(LagrangianPatchField< scalar > &f, const LagrangianPatchField< Type > &f1)
Definition: LagrangianPatchFieldFunctions.H:60
Foam::min
layerAndWeight min(const layerAndWeight &a, const layerAndWeight &b)
Definition: moving_fvMeshStitcher.C:110
Foam::component
void component(LagrangianPatchField< typename LagrangianPatchField< Type >::cmptType > &sf, const LagrangianPatchField< Type > &f, const direction d)
Definition: LagrangianPatchFieldFunctions.H:41
Foam::pow
void pow(LagrangianPatchField< typename powProduct< Type, r >::type > &f, const LagrangianPatchField< Type > &f1)
Definition: LagrangianPatchFieldFunctions.H:75
Foam::multiply
void multiply(LagrangianPatchField< Type > &f, const LagrangianPatchField< scalar > &f1, const LagrangianPatchField< Type > &f2)
Definition: LagrangianPatchFieldFunctions.H:160
Foam::transform
dimensionSet transform(const dimensionSet &)
Definition: dimensionSet.C:501
Foam::cmptAv
void cmptAv(LagrangianPatchField< typename LagrangianPatchField< Type >::cmptType > &f, const LagrangianPatchField< Type > &f1)
Definition: LagrangianPatchFieldFunctions.H:67
Foam::sum
dimensioned< Type > sum(const DimensionedField< Type, GeoMesh, PrimitiveField > &df)
Definition: DimensionedFieldFunctions.C:375
Foam::max
layerAndWeight max(const layerAndWeight &a, const layerAndWeight &b)
Definition: moving_fvMeshStitcher.C:104
Foam::sqr
void sqr(LagrangianPatchField< typename outerProduct< Type, Type >::type > &f, const LagrangianPatchField< Type > &f1)
Definition: LagrangianPatchFieldFunctions.H:82
Foam::gAverage
Type gAverage(const FieldField< Field, Type > &f)
Definition: FieldFieldFunctions.C:566
Foam::name
word name(const LagrangianState state)
Return a string representation of a Lagrangian state enumeration.
Definition: LagrangianState.C:30
Foam::magSqr
void magSqr(LagrangianPatchField< scalar > &f, const LagrangianPatchField< Type > &f1)
Definition: LagrangianPatchFieldFunctions.H:59
Foam::gMin
Type gMin(const FieldField< Field, Type > &f)
Definition: FieldFieldFunctions.C:558
Foam::add
void add(LagrangianPatchField< typename typeOfSum< Type1, Type2 >::type > &f, const LagrangianPatchField< Type1 > &f1, const LagrangianPatchField< Type2 > &f2)
Definition: LagrangianPatchFieldFunctions.H:227
Foam::gMax
Type gMax(const FieldField< Field, Type > &f)
Definition: FieldFieldFunctions.C:557
Foam::cmptMag
void cmptMag(LagrangianPatchField< Type > &f, const LagrangianPatchField< Type > &f1)
Definition: LagrangianPatchFieldFunctions.H:68
Foam::direction
uint8_t direction
Definition: direction.H:45