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