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