DimensionedScalarField.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-2020 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 "DimensionedScalarField.H"
27 
28 #define TEMPLATE template<class GeoMesh>
29 #include "DimensionedFieldFunctionsM.C"
30 
31 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
32 
33 namespace Foam
34 {
35 
36 // * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
37 
38 template<class GeoMesh>
39 tmp<DimensionedField<scalar, GeoMesh>> stabilise
40 (
41  const DimensionedField<scalar, GeoMesh>& dsf,
42  const dimensioned<scalar>& ds
43 )
44 {
45  tmp<DimensionedField<scalar, GeoMesh>> tRes
46  (
47  DimensionedField<scalar, GeoMesh>::New
48  (
49  "stabilise(" + dsf.name() + ',' + ds.name() + ')',
50  dsf.mesh(),
51  dsf.dimensions() + ds.dimensions()
52  )
53  );
54 
55  stabilise(tRes.ref().field(), dsf.field(), ds.value());
56 
57  return tRes;
58 }
59 
60 
61 template<class GeoMesh>
62 tmp<DimensionedField<scalar, GeoMesh>> stabilise
63 (
64  const tmp<DimensionedField<scalar, GeoMesh>>& tdsf,
65  const dimensioned<scalar>& ds
66 )
67 {
68  const DimensionedField<scalar, GeoMesh>& dsf = tdsf();
69 
70  tmp<DimensionedField<scalar, GeoMesh>> tRes = New
71  (
72  tdsf,
73  "stabilise(" + dsf.name() + ',' + ds.name() + ')',
74  dsf.dimensions() + ds.dimensions()
75  );
76 
77  stabilise(tRes.ref().field(), dsf.field(), ds.value());
78 
79  tdsf.clear();
80 
81  return tRes;
82 }
83 
84 
85 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
86 
87 BINARY_TYPE_OPERATOR(scalar, scalar, scalar, +, '+', add)
88 BINARY_TYPE_OPERATOR(scalar, scalar, scalar, -, '-', subtract)
89 
90 BINARY_OPERATOR(scalar, scalar, scalar, *, '*', multiply)
91 BINARY_OPERATOR(scalar, scalar, scalar, /, '|', divide)
92 
93 BINARY_TYPE_OPERATOR_SF(scalar, scalar, scalar, /, '|', divide)
94 
95 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
96 
97 template<class GeoMesh>
98 tmp<DimensionedField<scalar, GeoMesh>> pow
99 (
100  const DimensionedField<scalar, GeoMesh>& dsf1,
101  const DimensionedField<scalar, GeoMesh>& dsf2
102 )
103 {
104  if (!dsf1.dimensions().dimensionless())
105  {
106  FatalErrorInFunction
107  << "Base field is not dimensionless: " << dsf1.dimensions()
108  << exit(FatalError);
109  }
110 
111  if (!dsf2.dimensions().dimensionless())
112  {
113  FatalErrorInFunction
114  << "Exponent field is not dimensionless: " << dsf2.dimensions()
115  << exit(FatalError);
116  }
117 
118  tmp<DimensionedField<scalar, GeoMesh>> tPow
119  (
120  DimensionedField<scalar, GeoMesh>::New
121  (
122  "pow(" + dsf1.name() + ',' + dsf2.name() + ')',
123  dsf1.mesh(),
124  dimless
125  )
126  );
127 
128  pow(tPow.ref().field(), dsf1.field(), dsf2.field());
129 
130  return tPow;
131 }
132 
133 
134 template<class GeoMesh>
135 tmp<DimensionedField<scalar, GeoMesh>> pow
136 (
137  const tmp<DimensionedField<scalar, GeoMesh>>& tdsf1,
138  const DimensionedField<scalar, GeoMesh>& dsf2
139 )
140 {
141  const DimensionedField<scalar, GeoMesh>& dsf1 = tdsf1();
142 
143  if (!dsf1.dimensions().dimensionless())
144  {
145  FatalErrorInFunction
146  << "Base field is not dimensionless: " << dsf1.dimensions()
147  << exit(FatalError);
148  }
149 
150  if (!dsf2.dimensions().dimensionless())
151  {
152  FatalErrorInFunction
153  << "Exponent field is not dimensionless: " << dsf2.dimensions()
154  << exit(FatalError);
155  }
156 
157  tmp<DimensionedField<scalar, GeoMesh>> tPow = New
158  (
159  tdsf1,
160  "pow(" + dsf1.name() + ',' + dsf2.name() + ')',
161  dimless
162  );
163 
164  pow(tPow.ref().field(), dsf1.field(), dsf2.field());
165 
166  tdsf1.clear();
167 
168  return tPow;
169 }
170 
171 
172 template<class GeoMesh>
173 tmp<DimensionedField<scalar, GeoMesh>> pow
174 (
175  const DimensionedField<scalar, GeoMesh>& dsf1,
176  const tmp<DimensionedField<scalar, GeoMesh>>& tdsf2
177 )
178 {
179  const DimensionedField<scalar, GeoMesh>& dsf2 = tdsf2();
180 
181  if (!dsf1.dimensions().dimensionless())
182  {
183  FatalErrorInFunction
184  << "Base field is not dimensionless: " << dsf1.dimensions()
185  << exit(FatalError);
186  }
187 
188  if (!dsf2.dimensions().dimensionless())
189  {
190  FatalErrorInFunction
191  << "Exponent field is not dimensionless: " << dsf2.dimensions()
192  << exit(FatalError);
193  }
194 
195  tmp<DimensionedField<scalar, GeoMesh>> tPow = New
196  (
197  tdsf2,
198  "pow(" + dsf1.name() + ',' + dsf2.name() + ')',
199  dimless
200  );
201 
202  pow(tPow.ref().field(), dsf1.field(), dsf2.field());
203 
204  tdsf2.clear();
205 
206  return tPow;
207 }
208 
209 
210 template<class GeoMesh>
211 tmp<DimensionedField<scalar, GeoMesh>> pow
212 (
213  const tmp<DimensionedField<scalar, GeoMesh>>& tdsf1,
214  const tmp<DimensionedField<scalar, GeoMesh>>& tdsf2
215 )
216 {
217  const DimensionedField<scalar, GeoMesh>& dsf1 = tdsf1();
218  const DimensionedField<scalar, GeoMesh>& dsf2 = tdsf2();
219 
220  if (!dsf1.dimensions().dimensionless())
221  {
222  FatalErrorInFunction
223  << "Base field is not dimensionless: " << dsf1.dimensions()
224  << exit(FatalError);
225  }
226 
227  if (!dsf2.dimensions().dimensionless())
228  {
229  FatalErrorInFunction
230  << "Exponent field is not dimensionless: " << dsf2.dimensions()
231  << exit(FatalError);
232  }
233 
234  tmp<DimensionedField<scalar, GeoMesh>> tPow =
235  reuseTmpTmpDimensionedField<scalar, scalar, scalar, GeoMesh>::New
236  (
237  tdsf1,
238  tdsf2,
239  "pow(" + dsf1.name() + ',' + dsf2.name() + ')',
240  dimless
241  );
242 
243  pow(tPow.ref().field(), dsf1.field(), dsf2.field());
244 
245  tdsf1.clear();
246  tdsf2.clear();
247 
248  return tPow;
249 }
250 
251 
252 template<class GeoMesh>
253 tmp<DimensionedField<scalar, GeoMesh>> pow
254 (
255  const DimensionedField<scalar, GeoMesh>& dsf,
256  const dimensionedScalar& ds
257 )
258 {
259  if (!ds.dimensions().dimensionless())
260  {
261  FatalErrorInFunction
262  << "Exponent is not dimensionless: " << ds.dimensions()
263  << exit(FatalError);
264  }
265 
266  tmp<DimensionedField<scalar, GeoMesh>> tPow
267  (
268  DimensionedField<scalar, GeoMesh>::New
269  (
270  "pow(" + dsf.name() + ',' + ds.name() + ')',
271  dsf.mesh(),
272  pow(dsf.dimensions(), ds)
273  )
274  );
275 
276  pow(tPow.ref().field(), dsf.field(), ds.value());
277 
278  return tPow;
279 }
280 
281 
282 template<class GeoMesh>
283 tmp<DimensionedField<scalar, GeoMesh>> pow
284 (
285  const tmp<DimensionedField<scalar, GeoMesh>>& tdsf,
286  const dimensionedScalar& ds
287 )
288 {
289  if (!ds.dimensions().dimensionless())
290  {
291  FatalErrorInFunction
292  << "Exponent is not dimensionless: " << ds.dimensions()
293  << exit(FatalError);
294  }
295 
296  const DimensionedField<scalar, GeoMesh>& dsf = tdsf();
297 
298  tmp<DimensionedField<scalar, GeoMesh>> tPow = New
299  (
300  tdsf,
301  "pow(" + dsf.name() + ',' + ds.name() + ')',
302  pow(dsf.dimensions(), ds)
303  );
304 
305  pow(tPow.ref().field(), dsf.field(), ds.value());
306 
307  tdsf.clear();
308 
309  return tPow;
310 }
311 
312 
313 template<class GeoMesh>
314 tmp<DimensionedField<scalar, GeoMesh>> pow
315 (
316  const DimensionedField<scalar, GeoMesh>& dsf,
317  const scalar& s
318 )
319 {
320  return pow(dsf, dimensionedScalar(s));
321 }
322 
323 
324 template<class GeoMesh>
325 tmp<DimensionedField<scalar, GeoMesh>> pow
326 (
327  const tmp<DimensionedField<scalar, GeoMesh>>& tdsf,
328  const scalar& s
329 )
330 {
331  return pow(tdsf, dimensionedScalar(s));
332 }
333 
334 
335 template<class GeoMesh>
336 tmp<DimensionedField<scalar, GeoMesh>> pow
337 (
338  const dimensionedScalar& ds,
339  const DimensionedField<scalar, GeoMesh>& dsf
340 )
341 {
342  if (!ds.dimensions().dimensionless())
343  {
344  FatalErrorInFunction
345  << "Base scalar is not dimensionless: " << ds.dimensions()
346  << exit(FatalError);
347  }
348 
349  if (!dsf.dimensions().dimensionless())
350  {
351  FatalErrorInFunction
352  << "Exponent field is not dimensionless: " << dsf.dimensions()
353  << exit(FatalError);
354  }
355 
356  tmp<DimensionedField<scalar, GeoMesh>> tPow
357  (
358  DimensionedField<scalar, GeoMesh>::New
359  (
360  "pow(" + ds.name() + ',' + dsf.name() + ')',
361  dsf.mesh(),
362  dimless
363  )
364  );
365 
366  pow(tPow.ref().field(), ds.value(), dsf.field());
367 
368  return tPow;
369 }
370 
371 
372 template<class GeoMesh>
373 tmp<DimensionedField<scalar, GeoMesh>> pow
374 (
375  const dimensionedScalar& ds,
376  const tmp<DimensionedField<scalar, GeoMesh>>& tdsf
377 )
378 {
379  const DimensionedField<scalar, GeoMesh>& dsf = tdsf();
380 
381  if (!ds.dimensions().dimensionless())
382  {
383  FatalErrorInFunction
384  << "Base scalar is not dimensionless: " << ds.dimensions()
385  << exit(FatalError);
386  }
387 
388  if (!dsf.dimensions().dimensionless())
389  {
390  FatalErrorInFunction
391  << "Exponent field is not dimensionless: " << dsf.dimensions()
392  << exit(FatalError);
393  }
394 
395  tmp<DimensionedField<scalar, GeoMesh>> tPow = New
396  (
397  tdsf,
398  "pow(" + ds.name() + ',' + dsf.name() + ')',
399  dimless
400  );
401 
402  pow(tPow.ref().field(), ds.value(), dsf.field());
403 
404  tdsf.clear();
405 
406  return tPow;
407 }
408 
409 template<class GeoMesh>
410 tmp<DimensionedField<scalar, GeoMesh>> pow
411 (
412  const scalar& s,
413  const DimensionedField<scalar, GeoMesh>& dsf
414 )
415 {
416  return pow(dimensionedScalar(s), dsf);
417 }
418 
419 template<class GeoMesh>
420 tmp<DimensionedField<scalar, GeoMesh>> pow
421 (
422  const scalar& s,
423  const tmp<DimensionedField<scalar, GeoMesh>>& tdsf
424 )
425 {
426  return pow(dimensionedScalar(s), tdsf);
427 }
428 
429 
430 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
431 
432 template<class GeoMesh>
433 tmp<DimensionedField<scalar, GeoMesh>> atan2
434 (
435  const DimensionedField<scalar, GeoMesh>& dsf1,
436  const DimensionedField<scalar, GeoMesh>& dsf2
437 )
438 {
439  tmp<DimensionedField<scalar, GeoMesh>> tAtan2
440  (
441  DimensionedField<scalar, GeoMesh>::New
442  (
443  "atan2(" + dsf1.name() + ',' + dsf2.name() + ')',
444  dsf1.mesh(),
445  atan2(dsf1.dimensions(), dsf2.dimensions())
446  )
447  );
448 
449  atan2(tAtan2.ref().field(), dsf1.field(), dsf2.field());
450 
451  return tAtan2;
452 }
453 
454 
455 template<class GeoMesh>
456 tmp<DimensionedField<scalar, GeoMesh>> atan2
457 (
458  const tmp<DimensionedField<scalar, GeoMesh>>& tdsf1,
459  const DimensionedField<scalar, GeoMesh>& dsf2
460 )
461 {
462  const DimensionedField<scalar, GeoMesh>& dsf1 = tdsf1();
463 
464  tmp<DimensionedField<scalar, GeoMesh>> tAtan2 = New
465  (
466  tdsf1,
467  "atan2(" + dsf1.name() + ',' + dsf2.name() + ')',
468  atan2(dsf1.dimensions(), dsf2.dimensions())
469  );
470 
471  atan2(tAtan2.ref().field(), dsf1.field(), dsf2.field());
472 
473  tdsf1.clear();
474 
475  return tAtan2;
476 }
477 
478 
479 template<class GeoMesh>
480 tmp<DimensionedField<scalar, GeoMesh>> atan2
481 (
482  const DimensionedField<scalar, GeoMesh>& dsf1,
483  const tmp<DimensionedField<scalar, GeoMesh>>& tdsf2
484 )
485 {
486  const DimensionedField<scalar, GeoMesh>& dsf2 = tdsf2();
487 
488  tmp<DimensionedField<scalar, GeoMesh>> tAtan2 = New
489  (
490  tdsf2,
491  "atan2(" + dsf1.name() + ',' + dsf2.name() + ')',
492  atan2(dsf1.dimensions(), dsf2.dimensions())
493  );
494 
495  atan2(tAtan2.ref().field(), dsf1.field(), dsf2.field());
496 
497  tdsf2.clear();
498 
499  return tAtan2;
500 }
501 
502 template<class GeoMesh>
503 tmp<DimensionedField<scalar, GeoMesh>> atan2
504 (
505  const tmp<DimensionedField<scalar, GeoMesh>>& tdsf1,
506  const tmp<DimensionedField<scalar, GeoMesh>>& tdsf2
507 )
508 {
509  const DimensionedField<scalar, GeoMesh>& dsf1 = tdsf1();
510  const DimensionedField<scalar, GeoMesh>& dsf2 = tdsf2();
511 
512  tmp<DimensionedField<scalar, GeoMesh>> tAtan2 =
513  reuseTmpTmpDimensionedField<scalar, scalar, scalar, GeoMesh>::New
514  (
515  tdsf1,
516  tdsf2,
517  "atan2(" + dsf1.name() + ',' + dsf2.name() + ')',
518  atan2(dsf1.dimensions(), dsf2.dimensions())
519  );
520 
521  atan2(tAtan2.ref().field(), dsf1.field(), dsf2.field());
522 
523  tdsf1.clear();
524  tdsf2.clear();
525 
526  return tAtan2;
527 }
528 
529 
530 template<class GeoMesh>
531 tmp<DimensionedField<scalar, GeoMesh>> atan2
532 (
533  const DimensionedField<scalar, GeoMesh>& dsf,
534  const dimensionedScalar& ds
535 )
536 {
537  tmp<DimensionedField<scalar, GeoMesh>> tAtan2
538  (
539  DimensionedField<scalar, GeoMesh>::New
540  (
541  "atan2(" + dsf.name() + ',' + ds.name() + ')',
542  dsf.mesh(),
543  atan2(dsf.dimensions(), ds)
544  )
545  );
546 
547  atan2(tAtan2.ref().field(), dsf.field(), ds.value());
548 
549  return tAtan2;
550 }
551 
552 template<class GeoMesh>
553 tmp<DimensionedField<scalar, GeoMesh>> atan2
554 (
555  const tmp<DimensionedField<scalar, GeoMesh>>& tdsf,
556  const dimensionedScalar& ds
557 )
558 {
559  const DimensionedField<scalar, GeoMesh>& dsf = tdsf();
560 
561  tmp<DimensionedField<scalar, GeoMesh>> tAtan2 = New
562  (
563  tdsf,
564  "atan2(" + dsf.name() + ',' + ds.name() + ')',
565  atan2(dsf.dimensions(), ds)
566  );
567 
568  atan2(tAtan2.ref().field(), dsf.field(), ds.value());
569 
570  tdsf.clear();
571 
572  return tAtan2;
573 }
574 
575 template<class GeoMesh>
576 tmp<DimensionedField<scalar, GeoMesh>> atan2
577 (
578  const DimensionedField<scalar, GeoMesh>& dsf,
579  const scalar& s
580 )
581 {
582  return atan2(dsf, dimensionedScalar(s));
583 }
584 
585 template<class GeoMesh>
586 tmp<DimensionedField<scalar, GeoMesh>> atan2
587 (
588  const tmp<DimensionedField<scalar, GeoMesh>>& tdsf,
589  const scalar& s
590 )
591 {
592  return atan2(tdsf, dimensionedScalar(s));
593 }
594 
595 
596 template<class GeoMesh>
597 tmp<DimensionedField<scalar, GeoMesh>> atan2
598 (
599  const dimensionedScalar& ds,
600  const DimensionedField<scalar, GeoMesh>& dsf
601 )
602 {
603  tmp<DimensionedField<scalar, GeoMesh>> tAtan2
604  (
605  DimensionedField<scalar, GeoMesh>::New
606  (
607  "atan2(" + ds.name() + ',' + dsf.name() + ')',
608  dsf.mesh(),
609  atan2(ds, dsf.dimensions())
610  )
611  );
612 
613  atan2(tAtan2.ref().field(), ds.value(), dsf.field());
614 
615  return tAtan2;
616 }
617 
618 
619 template<class GeoMesh>
620 tmp<DimensionedField<scalar, GeoMesh>> atan2
621 (
622  const dimensionedScalar& ds,
623  const tmp<DimensionedField<scalar, GeoMesh>>& tdsf
624 )
625 {
626  const DimensionedField<scalar, GeoMesh>& dsf = tdsf();
627 
628  tmp<DimensionedField<scalar, GeoMesh>> tAtan2 = New
629  (
630  tdsf,
631  "atan2(" + ds.name() + ',' + dsf.name() + ')',
632  atan2(ds, dsf.dimensions())
633  );
634 
635  atan2(tAtan2.ref().field(), ds.value(), dsf.field());
636 
637  tdsf.clear();
638 
639  return tAtan2;
640 }
641 
642 template<class GeoMesh>
643 tmp<DimensionedField<scalar, GeoMesh>> atan2
644 (
645  const scalar& s,
646  const DimensionedField<scalar, GeoMesh>& dsf
647 )
648 {
649  return atan2(dimensionedScalar(s), dsf);
650 }
651 
652 template<class GeoMesh>
653 tmp<DimensionedField<scalar, GeoMesh>> atan2
654 (
655  const scalar& s,
656  const tmp<DimensionedField<scalar, GeoMesh>>& tdsf
657 )
658 {
659  return atan2(dimensionedScalar(s), tdsf);
660 }
661 
662 
663 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
664 
665 UNARY_FUNCTION(scalar, scalar, pow3, pow3)
666 UNARY_FUNCTION(scalar, scalar, pow4, pow4)
667 UNARY_FUNCTION(scalar, scalar, pow5, pow5)
668 UNARY_FUNCTION(scalar, scalar, pow6, pow6)
669 UNARY_FUNCTION(scalar, scalar, pow025, pow025)
670 UNARY_FUNCTION(scalar, scalar, sqrt, sqrt)
671 UNARY_FUNCTION(scalar, scalar, cbrt, cbrt)
672 UNARY_FUNCTION(scalar, scalar, sign, sign)
673 UNARY_FUNCTION(scalar, scalar, pos, pos)
674 UNARY_FUNCTION(scalar, scalar, pos0, pos0)
675 UNARY_FUNCTION(scalar, scalar, neg, neg)
676 UNARY_FUNCTION(scalar, scalar, neg0, neg0)
677 UNARY_FUNCTION(scalar, scalar, posPart, posPart)
678 UNARY_FUNCTION(scalar, scalar, negPart, negPart)
679 
680 UNARY_FUNCTION(scalar, scalar, exp, trans)
681 UNARY_FUNCTION(scalar, scalar, log, trans)
682 UNARY_FUNCTION(scalar, scalar, log10, trans)
683 UNARY_FUNCTION(scalar, scalar, sin, trans)
684 UNARY_FUNCTION(scalar, scalar, cos, trans)
685 UNARY_FUNCTION(scalar, scalar, tan, trans)
686 UNARY_FUNCTION(scalar, scalar, asin, trans)
687 UNARY_FUNCTION(scalar, scalar, acos, trans)
688 UNARY_FUNCTION(scalar, scalar, atan, trans)
689 UNARY_FUNCTION(scalar, scalar, sinh, trans)
690 UNARY_FUNCTION(scalar, scalar, cosh, trans)
691 UNARY_FUNCTION(scalar, scalar, tanh, trans)
692 UNARY_FUNCTION(scalar, scalar, asinh, trans)
693 UNARY_FUNCTION(scalar, scalar, acosh, trans)
694 UNARY_FUNCTION(scalar, scalar, atanh, trans)
695 UNARY_FUNCTION(scalar, scalar, erf, trans)
696 UNARY_FUNCTION(scalar, scalar, erfc, trans)
697 UNARY_FUNCTION(scalar, scalar, lgamma, trans)
698 UNARY_FUNCTION(scalar, scalar, j0, trans)
699 UNARY_FUNCTION(scalar, scalar, j1, trans)
700 UNARY_FUNCTION(scalar, scalar, y0, trans)
701 UNARY_FUNCTION(scalar, scalar, y1, trans)
702 
703 
704 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
705 
706 #define BesselFunc(func) \
707  \
708 template<class GeoMesh> \
709 tmp<DimensionedField<scalar, GeoMesh>> func \
710 ( \
711  const int n, \
712  const DimensionedField<scalar, GeoMesh>& dsf \
713 ) \
714 { \
715  if (!dsf.dimensions().dimensionless()) \
716  { \
717  FatalErrorInFunction \
718  << "dsf not dimensionless" \
719  << abort(FatalError); \
720  } \
721  \
722  tmp<DimensionedField<scalar, GeoMesh>> tFunc \
723  ( \
724  DimensionedField<scalar, GeoMesh>::New \
725  ( \
726  #func "(" + name(n) + ',' + dsf.name() + ')', \
727  dsf.mesh(), \
728  dimless \
729  ) \
730  ); \
731  \
732  func(tFunc.ref().field(), n, dsf.field()); \
733  \
734  return tFunc; \
735 } \
736  \
737 template<class GeoMesh> \
738 tmp<DimensionedField<scalar, GeoMesh>> func \
739 ( \
740  const int n, \
741  const tmp<DimensionedField<scalar, GeoMesh>>& tdsf \
742 ) \
743 { \
744  const DimensionedField<scalar, GeoMesh>& dsf = tdsf(); \
745  \
746  if (!dsf.dimensions().dimensionless()) \
747  { \
748  FatalErrorInFunction \
749  << " : dsf not dimensionless" \
750  << abort(FatalError); \
751  } \
752  \
753  tmp<DimensionedField<scalar, GeoMesh>> tFunc \
754  ( \
755  New \
756  ( \
757  tdsf, \
758  #func "(" + name(n) + ',' + dsf.name() + ')', \
759  dimless \
760  ) \
761  ); \
762  \
763  func(tFunc.ref().field(), n, dsf.field()); \
764  \
765  tdsf.clear(); \
766  \
767  return tFunc; \
768 }
769 
770 BesselFunc(jn)
771 BesselFunc(yn)
772 
773 #undef BesselFunc
774 
775 
776 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
777 
778 } // End namespace Foam
779 
780 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
781 
782 #include "undefFieldFunctionsM.H"
783 
784 // ************************************************************************* //
Foam::divide
void divide(FieldField< Field, Type > &f, const FieldField< Field, Type > &f1, const FieldField< Field, scalar > &f2)
Foam::sign
dimensionedScalar sign(const dimensionedScalar &ds)
Definition: dimensionedScalar.C:179
Foam::tanh
dimensionedScalar tanh(const dimensionedScalar &ds)
Definition: dimensionedScalar.C:285
Foam::trans
dimensionSet trans(const dimensionSet &)
Definition: dimensionSet.C:450
Foam::acos
dimensionedScalar acos(const dimensionedScalar &ds)
Definition: dimensionedScalar.C:281
BINARY_OPERATOR
#define BINARY_OPERATOR(ReturnType, Type1, Type2, Op, OpName, OpFunc)
Definition: DimensionedFieldFunctionsM.C:391
Foam::reuseTmpTmpDimensionedField::New
static tmp< DimensionedField< TypeR, GeoMesh > > New(const tmp< DimensionedField< Type1, GeoMesh >> &tdf1, const tmp< DimensionedField< Type2, GeoMesh >> &tdf2, const word &name, const dimensionSet &dimensions)
Definition: DimensionedFieldReuseFunctions.H:129
Foam::multiply
void multiply(FieldField< Field, Type > &f, const FieldField< Field, Type > &f1, const FieldField< Field, scalar > &f2)
Foam::IOobject::name
const word & name() const
Return name.
Definition: IOobject.H:303
Foam::log
dimensionedScalar log(const dimensionedScalar &ds)
Definition: dimensionedScalar.C:275
Foam::exit
errorManipArg< error, int > exit(error &err, const int errNo=1)
Definition: errorManip.H:124
Foam::FatalError
error FatalError
FatalErrorInFunction
#define FatalErrorInFunction
Report an error message using Foam::FatalError.
Definition: error.H:323
UNARY_FUNCTION
#define UNARY_FUNCTION(ReturnType, Type1, Func, Dfunc)
Definition: DimensionedFieldFunctionsM.C:30
Foam::tmp::ref
T & ref() const
Return non-const reference or generate a fatal error.
Definition: tmpI.H:181
Foam::yn
dimensionedScalar yn(const int n, const dimensionedScalar &ds)
Definition: dimensionedScalar.C:319
BINARY_TYPE_OPERATOR_SF
#define BINARY_TYPE_OPERATOR_SF(ReturnType, Type1, Type2, Op, OpName, OpFunc)
Definition: DimensionedFieldFunctionsM.C:499
Foam::sqrt
dimensionedScalar sqrt(const dimensionedScalar &ds)
Definition: dimensionedScalar.C:142
Foam::pow025
dimensionedScalar pow025(const dimensionedScalar &ds)
Definition: dimensionedScalar.C:131
Foam::y0
dimensionedScalar y0(const dimensionedScalar &ds)
Definition: dimensionedScalar.C:294
Foam::dimless
const dimensionSet dimless
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:901
Foam::posPart
dimensionedScalar posPart(const dimensionedScalar &ds)
Definition: dimensionedScalar.C:234
Foam::neg
dimensionedScalar neg(const dimensionedScalar &ds)
Definition: dimensionedScalar.C:212
Foam::asin
dimensionedScalar asin(const dimensionedScalar &ds)
Definition: dimensionedScalar.C:280
Foam::pow5
dimensionedScalar pow5(const dimensionedScalar &ds)
Definition: dimensionedScalar.C:109
Foam::j1
dimensionedScalar j1(const dimensionedScalar &ds)
Definition: dimensionedScalar.C:293
Foam::New
tmp< DimensionedField< TypeR, GeoMesh > > New(const tmp< DimensionedField< TypeR, GeoMesh >> &tdf1, const word &name, const dimensionSet &dimensions)
Definition: DimensionedFieldReuseFunctions.H:38
Foam::pos
dimensionedScalar pos(const dimensionedScalar &ds)
Definition: dimensionedScalar.C:190
Foam::DimensionedField::dimensions
const dimensionSet & dimensions() const
Return dimensions.
Definition: DimensionedFieldI.H:46
Foam::acosh
dimensionedScalar acosh(const dimensionedScalar &ds)
Definition: dimensionedScalar.C:287
Foam::cos
dimensionedScalar cos(const dimensionedScalar &ds)
Definition: dimensionedScalar.C:278
Foam::exp
dimensionedScalar exp(const dimensionedScalar &ds)
Definition: dimensionedScalar.C:274
Foam::asinh
dimensionedScalar asinh(const dimensionedScalar &ds)
Definition: dimensionedScalar.C:286
Foam::jn
dimensionedScalar jn(const int n, const dimensionedScalar &ds)
Definition: dimensionedScalar.C:318
Foam::cbrt
dimensionedScalar cbrt(const dimensionedScalar &ds)
Definition: dimensionedScalar.C:153
Foam::neg0
dimensionedScalar neg0(const dimensionedScalar &ds)
Definition: dimensionedScalar.C:223
BesselFunc
#define BesselFunc(func)
Definition: DimensionedScalarField.C:706
Foam::dimensioned::value
const Type & value() const
Return const reference to value.
Definition: dimensionedType.C:283
Foam::atanh
dimensionedScalar atanh(const dimensionedScalar &ds)
Definition: dimensionedScalar.C:288
Foam::y1
dimensionedScalar y1(const dimensionedScalar &ds)
Definition: dimensionedScalar.C:295
Foam::pos0
dimensionedScalar pos0(const dimensionedScalar &ds)
Definition: dimensionedScalar.C:201
Foam::sin
dimensionedScalar sin(const dimensionedScalar &ds)
Definition: dimensionedScalar.C:277
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:900
Foam::erf
dimensionedScalar erf(const dimensionedScalar &ds)
Definition: dimensionedScalar.C:289
Foam::atan2
dimensionedScalar atan2(const dimensionedScalar &x, const dimensionedScalar &y)
Definition: dimensionedScalar.C:325
Foam::DimensionedField::mesh
const Mesh & mesh() const
Return mesh.
Definition: DimensionedFieldI.H:38
Foam::dimensioned::name
const word & name() const
Return const reference to name.
Definition: dimensionedType.C:257
Foam::DimensionedField::field
const Field< Type > & field() const
Definition: DimensionedFieldI.H:61
Foam::lgamma
dimensionedScalar lgamma(const dimensionedScalar &ds)
Definition: dimensionedScalar.C:291
Foam::pow
dimensionedScalar pow(const dimensionedScalar &ds, const dimensionedScalar &expt)
Definition: dimensionedScalar.C:73
Foam::pow3
dimensionedScalar pow3(const dimensionedScalar &ds)
Definition: dimensionedScalar.C:87
Foam::stabilise
tmp< DimensionedField< scalar, GeoMesh > > stabilise(const DimensionedField< scalar, GeoMesh > &dsf, const dimensioned< scalar > &ds)
Definition: DimensionedScalarField.C:40
Foam::erfc
dimensionedScalar erfc(const dimensionedScalar &ds)
Definition: dimensionedScalar.C:290
Foam::sinh
dimensionedScalar sinh(const dimensionedScalar &ds)
Definition: dimensionedScalar.C:283
Foam::dimensionedScalar
dimensioned< scalar > dimensionedScalar
Dimensioned scalar obtained from generic dimensioned type.
Definition: dimensionedScalarFwd.H:41
Foam::atan
dimensionedScalar atan(const dimensionedScalar &ds)
Definition: dimensionedScalar.C:282
Foam::DimensionedField
Field with dimensions and associated with geometry type GeoMesh which is used to size the field and a...
Definition: DimensionedField.H:51
Foam::pow4
dimensionedScalar pow4(const dimensionedScalar &ds)
Definition: dimensionedScalar.C:98
Foam::dimensioned::dimensions
const dimensionSet & dimensions() const
Return const reference to dimensions.
Definition: dimensionedType.C:270
Foam::pow6
dimensionedScalar pow6(const dimensionedScalar &ds)
Definition: dimensionedScalar.C:120
DimensionedScalarField.H
Scalar specific part of the implementation of DimensionedField.
Foam::cosh
dimensionedScalar cosh(const dimensionedScalar &ds)
Definition: dimensionedScalar.C:284
Foam::tmp
A class for managing temporary objects.
Definition: PtrList.H:53
Foam::tan
dimensionedScalar tan(const dimensionedScalar &ds)
Definition: dimensionedScalar.C:279
Foam::j0
dimensionedScalar j0(const dimensionedScalar &ds)
Definition: dimensionedScalar.C:292
BINARY_TYPE_OPERATOR
#define BINARY_TYPE_OPERATOR(ReturnType, Type1, Type2, Op, OpName, OpFunc)
Definition: DimensionedFieldFunctionsM.C:642
Foam::dimensionSet::dimensionless
bool dimensionless() const
Return true if it is dimensionless.
Definition: dimensionSet.C:89
Foam::log10
dimensionedScalar log10(const dimensionedScalar &ds)
Definition: dimensionedScalar.C:276
Foam
Namespace for OpenFOAM.
Definition: atmBoundaryLayer.H:213
Foam::negPart
dimensionedScalar negPart(const dimensionedScalar &ds)
Definition: dimensionedScalar.C:245