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