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