DimensionedScalarField.C
Go to the documentation of this file.
1 /*---------------------------------------------------------------------------*\
2  ========= |
3  \\ / F ield | OpenFOAM: The Open Source CFD Toolbox
4  \\ / O peration |
5  \\ / A nd | Copyright (C) 2011-2016 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, neg, neg)
712 UNARY_FUNCTION(scalar, scalar, posPart, posPart)
713 UNARY_FUNCTION(scalar, scalar, negPart, negPart)
714 
715 UNARY_FUNCTION(scalar, scalar, exp, trans)
716 UNARY_FUNCTION(scalar, scalar, log, trans)
717 UNARY_FUNCTION(scalar, scalar, log10, trans)
718 UNARY_FUNCTION(scalar, scalar, sin, trans)
719 UNARY_FUNCTION(scalar, scalar, cos, trans)
720 UNARY_FUNCTION(scalar, scalar, tan, trans)
721 UNARY_FUNCTION(scalar, scalar, asin, trans)
722 UNARY_FUNCTION(scalar, scalar, acos, trans)
723 UNARY_FUNCTION(scalar, scalar, atan, trans)
724 UNARY_FUNCTION(scalar, scalar, sinh, trans)
725 UNARY_FUNCTION(scalar, scalar, cosh, trans)
726 UNARY_FUNCTION(scalar, scalar, tanh, trans)
727 UNARY_FUNCTION(scalar, scalar, asinh, trans)
728 UNARY_FUNCTION(scalar, scalar, acosh, trans)
729 UNARY_FUNCTION(scalar, scalar, atanh, trans)
730 UNARY_FUNCTION(scalar, scalar, erf, trans)
731 UNARY_FUNCTION(scalar, scalar, erfc, trans)
732 UNARY_FUNCTION(scalar, scalar, lgamma, trans)
733 UNARY_FUNCTION(scalar, scalar, j0, trans)
734 UNARY_FUNCTION(scalar, scalar, j1, trans)
735 UNARY_FUNCTION(scalar, scalar, y0, trans)
736 UNARY_FUNCTION(scalar, scalar, y1, trans)
737 
738 
739 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
740 
741 #define BesselFunc(func) \
742  \
743 template<class GeoMesh> \
744 tmp<DimensionedField<scalar, GeoMesh>> func \
745 ( \
746  const int n, \
747  const DimensionedField<scalar, GeoMesh>& dsf \
748 ) \
749 { \
750  if (!dsf.dimensions().dimensionless()) \
751  { \
752  FatalErrorInFunction \
753  << "dsf not dimensionless" \
754  << abort(FatalError); \
755  } \
756  \
757  tmp<DimensionedField<scalar, GeoMesh>> tFunc \
758  ( \
759  new DimensionedField<scalar, GeoMesh> \
760  ( \
761  IOobject \
762  ( \
763  #func "(" + name(n) + ',' + dsf.name() + ')', \
764  dsf.instance(), \
765  dsf.db() \
766  ), \
767  dsf.mesh(), \
768  dimless \
769  ) \
770  ); \
771  \
772  func(tFunc.ref().field(), n, dsf.field()); \
773  \
774  return tFunc; \
775 } \
776  \
777 template<class GeoMesh> \
778 tmp<DimensionedField<scalar, GeoMesh>> func \
779 ( \
780  const int n, \
781  const tmp<DimensionedField<scalar, GeoMesh>>& tdsf \
782 ) \
783 { \
784  const DimensionedField<scalar, GeoMesh>& dsf = tdsf(); \
785  \
786  if (!dsf.dimensions().dimensionless()) \
787  { \
788  FatalErrorInFunction \
789  << " : dsf not dimensionless" \
790  << abort(FatalError); \
791  } \
792  \
793  tmp<DimensionedField<scalar, GeoMesh>> tFunc \
794  ( \
795  New \
796  ( \
797  tdsf, \
798  #func "(" + name(n) + ',' + dsf.name() + ')', \
799  dimless \
800  ) \
801  ); \
802  \
803  func(tFunc.ref().field(), n, dsf.field()); \
804  \
805  tdsf.clear(); \
806  \
807  return tFunc; \
808 }
809 
810 BesselFunc(jn)
811 BesselFunc(yn)
812 
813 #undef BesselFunc
814 
815 
816 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
817 
818 } // End namespace Foam
819 
820 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
821 
822 #include "undefFieldFunctionsM.H"
823 
824 // ************************************************************************* //
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:263
Foam::trans
dimensionSet trans(const dimensionSet &)
Definition: dimensionSet.C:438
Foam::acos
dimensionedScalar acos(const dimensionedScalar &ds)
Definition: dimensionedScalar.C:259
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::log
dimensionedScalar log(const dimensionedScalar &ds)
Definition: dimensionedScalar.C:253
Foam::IOobject::db
const objectRegistry & db() const
Return the local objectRegistry.
Definition: IOobject.C:221
Foam::exit
errorManipArg< error, int > exit(error &err, const int errNo=1)
Definition: errorManip.H:124
Foam::dimensioned::dimensions
const dimensionSet & dimensions() const
Return const reference to dimensions.
Definition: dimensionedType.C:248
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::yn
dimensionedScalar yn(const int n, const dimensionedScalar &ds)
Definition: dimensionedScalar.C:297
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:272
Foam::dimensioned::value
const Type & value() const
Return const reference to value.
Definition: dimensionedType.C:261
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:212
Foam::neg
dimensionedScalar neg(const dimensionedScalar &ds)
Definition: dimensionedScalar.C:201
Foam::asin
dimensionedScalar asin(const dimensionedScalar &ds)
Definition: dimensionedScalar.C:258
Foam::pow5
dimensionedScalar pow5(const dimensionedScalar &ds)
Definition: dimensionedScalar.C:109
Foam::j1
dimensionedScalar j1(const dimensionedScalar &ds)
Definition: dimensionedScalar.C:271
Foam::New
tmp< DimensionedField< TypeR, GeoMesh > > New(const tmp< DimensionedField< TypeR, GeoMesh >> &tdf1, const word &name, const dimensionSet &dimensions)
Definition: DimensionedFieldReuseFunctions.H:38
Foam::dimensioned::name
const word & name() const
Return const reference to name.
Definition: dimensionedType.C:235
Foam::pos
dimensionedScalar pos(const dimensionedScalar &ds)
Definition: dimensionedScalar.C:190
Foam::acosh
dimensionedScalar acosh(const dimensionedScalar &ds)
Definition: dimensionedScalar.C:265
Foam::cos
dimensionedScalar cos(const dimensionedScalar &ds)
Definition: dimensionedScalar.C:256
Foam::exp
dimensionedScalar exp(const dimensionedScalar &ds)
Definition: dimensionedScalar.C:252
Foam::asinh
dimensionedScalar asinh(const dimensionedScalar &ds)
Definition: dimensionedScalar.C:264
Foam::jn
dimensionedScalar jn(const int n, const dimensionedScalar &ds)
Definition: dimensionedScalar.C:296
Foam::cbrt
dimensionedScalar cbrt(const dimensionedScalar &ds)
Definition: dimensionedScalar.C:153
BesselFunc
#define BesselFunc(func)
Definition: DimensionedScalarField.C:741
Foam::atanh
dimensionedScalar atanh(const dimensionedScalar &ds)
Definition: dimensionedScalar.C:266
Foam::y1
dimensionedScalar y1(const dimensionedScalar &ds)
Definition: dimensionedScalar.C:273
Foam::DimensionedField::dimensions
const dimensionSet & dimensions() const
Return dimensions.
Definition: DimensionedFieldI.H:46
Foam::DimensionedField::field
const Field< Type > & field() const
Definition: DimensionedFieldI.H:61
Foam::sin
dimensionedScalar sin(const dimensionedScalar &ds)
Definition: dimensionedScalar.C:255
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:267
Foam::atan2
dimensionedScalar atan2(const dimensionedScalar &x, const dimensionedScalar &y)
Definition: dimensionedScalar.C:303
Foam::lgamma
dimensionedScalar lgamma(const dimensionedScalar &ds)
Definition: dimensionedScalar.C:269
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:268
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:261
Foam::dimensionedScalar
dimensioned< scalar > dimensionedScalar
Dimensioned scalar obtained from generic dimensioned type.
Definition: dimensionedScalarFwd.H:41
Foam::dimensionSet::dimensionless
bool dimensionless() const
Return true if it is dimensionless.
Definition: dimensionSet.C:89
Foam::DimensionedField::mesh
const Mesh & mesh() const
Return mesh.
Definition: DimensionedFieldI.H:38
Foam::atan
dimensionedScalar atan(const dimensionedScalar &ds)
Definition: dimensionedScalar.C:260
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::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:262
Foam::tmp
A class for managing temporary objects.
Definition: PtrList.H:54
Foam::tan
dimensionedScalar tan(const dimensionedScalar &ds)
Definition: dimensionedScalar.C:257
Foam::tmp::ref
T & ref() const
Return non-const reference or generate a fatal error.
Definition: tmpI.H:174
Foam::j0
dimensionedScalar j0(const dimensionedScalar &ds)
Definition: dimensionedScalar.C:270
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:91
Foam::IOobject::instance
const fileName & instance() const
Definition: IOobject.H:337
Foam::log10
dimensionedScalar log10(const dimensionedScalar &ds)
Definition: dimensionedScalar.C:254
Foam::IOobject::name
const word & name() const
Return name.
Definition: IOobject.H:260
Foam
Namespace for OpenFOAM.
Definition: combustionModel.C:30
Foam::negPart
dimensionedScalar negPart(const dimensionedScalar &ds)
Definition: dimensionedScalar.C:223
Generated by   doxygen 1.8.11