GeometricScalarField.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 "GeometricScalarField.H"
27 
28 #define TEMPLATE \
29  template \
30  < \
31  class GeoMesh, \
32  template<class> class PrimitiveField \
33  >
34 #define TEMPLATE2 \
35  template \
36  < \
37  class GeoMesh, \
38  template<class> class PrimitiveField1, \
39  template<class> class PrimitiveField2 \
40  >
41 #define TEMPLATE3 \
42  template \
43  < \
44  class GeoMesh, \
45  template<class> class PrimitiveField1, \
46  template<class> class PrimitiveField2, \
47  template<class> class PrimitiveField3 \
48  >
49 #include "GeometricFieldFunctionsM.C"
50 
51 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
52 
53 namespace Foam
54 {
55 
56 // * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
57 
58 TEMPLATE2
59 void stabilise
60 (
61  GeometricField<scalar, GeoMesh, PrimitiveField1>& result,
62  const GeometricField<scalar, GeoMesh, PrimitiveField2>& gsf,
63  const dimensioned<scalar>& ds
64 )
65 {
66  stabilise(result.primitiveFieldRef(), gsf.primitiveField(), ds.value());
67  stabilise(result.boundaryFieldRef(), gsf.boundaryField(), ds.value());
68 }
69 
70 
71 TEMPLATE
72 tmp<GeometricField<scalar, GeoMesh, Field>> stabilise
73 (
74  const GeometricField<scalar, GeoMesh, PrimitiveField>& gsf,
75  const dimensioned<scalar>& ds
76 )
77 {
78  tmp<GeometricField<scalar, GeoMesh, Field>> tRes
79  (
80  GeometricField<scalar, GeoMesh, Field>::New
81  (
82  "stabilise(" + gsf.name() + ',' + ds.name() + ')',
83  gsf.mesh(),
84  ds.dimensions() + gsf.dimensions()
85  )
86  );
87 
88  stabilise(tRes.ref(), gsf, ds);
89 
90  return tRes;
91 }
92 
93 
94 TEMPLATE
95 tmp<GeometricField<scalar, GeoMesh, Field>> stabilise
96 (
97  const tmp<GeometricField<scalar, GeoMesh, PrimitiveField>>& tgsf,
98  const dimensioned<scalar>& ds
99 )
100 {
101  const GeometricField<scalar, GeoMesh, PrimitiveField>& gsf = tgsf();
102 
103  tmp<GeometricField<scalar, GeoMesh, Field>> tRes
104  (
105  New
106  (
107  tgsf,
108  "stabilise(" + gsf.name() + ',' + ds.name() + ')',
109  ds.dimensions() + gsf.dimensions()
110  )
111  );
112 
113  stabilise(tRes.ref(), gsf, ds);
114 
115  tgsf.clear();
116 
117  return tRes;
118 }
119 
120 
121 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
122 
123 BINARY_TYPE_OPERATOR(scalar, scalar, scalar, +, '+', add)
124 BINARY_TYPE_OPERATOR(scalar, scalar, scalar, -, '-', subtract)
125 
126 BINARY_OPERATOR(scalar, scalar, scalar, *, '*', multiply)
127 BINARY_OPERATOR(scalar, scalar, scalar, /, '|', divide)
128 
129 BINARY_TYPE_OPERATOR_SF(scalar, scalar, scalar, /, '|', divide)
130 
131 
132 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
133 
134 TEMPLATE3
135 void pow
136 (
137  GeometricField<scalar, GeoMesh, PrimitiveField1>& Pow,
138  const GeometricField<scalar, GeoMesh, PrimitiveField2>& gsf1,
139  const GeometricField<scalar, GeoMesh, PrimitiveField3>& gsf2
140 )
141 {
142  pow(Pow.primitiveFieldRef(), gsf1.primitiveField(), gsf2.primitiveField());
143  pow(Pow.boundaryFieldRef(), gsf1.boundaryField(), gsf2.boundaryField());
144 }
145 
146 
147 TEMPLATE2
148 tmp<GeometricField<scalar, GeoMesh, Field>> pow
149 (
150  const GeometricField<scalar, GeoMesh, PrimitiveField1>& gsf1,
151  const GeometricField<scalar, GeoMesh, PrimitiveField2>& gsf2
152 )
153 {
154  if (!gsf1.dimensions().dimensionless())
155  {
156  FatalErrorInFunction
157  << "Base field is not dimensionless: " << gsf1.dimensions()
158  << exit(FatalError);
159  }
160 
161  if (!gsf2.dimensions().dimensionless())
162  {
163  FatalErrorInFunction
164  << "Exponent field is not dimensionless: " << gsf2.dimensions()
165  << exit(FatalError);
166  }
167 
168  tmp<GeometricField<scalar, GeoMesh, Field>> tPow
169  (
170  GeometricField<scalar, GeoMesh, Field>::New
171  (
172  "pow(" + gsf1.name() + ',' + gsf2.name() + ')',
173  gsf1.mesh(),
174  dimless
175  )
176  );
177 
178  pow(tPow.ref(), gsf1, gsf2);
179 
180  return tPow;
181 }
182 
183 
184 TEMPLATE2
185 tmp<GeometricField<scalar, GeoMesh, Field>> pow
186 (
187  const tmp<GeometricField<scalar, GeoMesh, PrimitiveField1>>& tgsf1,
188  const GeometricField<scalar, GeoMesh, PrimitiveField2>& gsf2
189 )
190 {
191  const GeometricField<scalar, GeoMesh, PrimitiveField1>& gsf1 =
192  tgsf1();
193 
194  if (!gsf1.dimensions().dimensionless())
195  {
196  FatalErrorInFunction
197  << "Base field is not dimensionless: " << gsf1.dimensions()
198  << exit(FatalError);
199  }
200 
201  if (!gsf2.dimensions().dimensionless())
202  {
203  FatalErrorInFunction
204  << "Exponent field is not dimensionless: " << gsf2.dimensions()
205  << exit(FatalError);
206  }
207 
208  tmp<GeometricField<scalar, GeoMesh, Field>> tPow
209  (
210  reuseTmpGeometricField<scalar, scalar, GeoMesh, PrimitiveField1>::New
211  (
212  tgsf1,
213  "pow(" + gsf1.name() + ',' + gsf2.name() + ')',
214  dimless
215  )
216  );
217 
218  pow(tPow.ref(), gsf1, gsf2);
219 
220  tgsf1.clear();
221 
222  return tPow;
223 }
224 
225 
226 TEMPLATE2
227 tmp<GeometricField<scalar, GeoMesh, Field>> pow
228 (
229  const GeometricField<scalar, GeoMesh, PrimitiveField1>& gsf1,
230  const tmp<GeometricField<scalar, GeoMesh, PrimitiveField2>>& tgsf2
231 )
232 {
233  const GeometricField<scalar, GeoMesh, PrimitiveField2>& gsf2 =
234  tgsf2();
235 
236  if (!gsf1.dimensions().dimensionless())
237  {
238  FatalErrorInFunction
239  << "Base field is not dimensionless: " << gsf1.dimensions()
240  << exit(FatalError);
241  }
242 
243  if (!gsf2.dimensions().dimensionless())
244  {
245  FatalErrorInFunction
246  << "Exponent field is not dimensionless: " << gsf2.dimensions()
247  << exit(FatalError);
248  }
249 
250  tmp<GeometricField<scalar, GeoMesh, Field>> tPow
251  (
252  reuseTmpGeometricField<scalar, scalar, GeoMesh, PrimitiveField2>::New
253  (
254  tgsf2,
255  "pow(" + gsf1.name() + ',' + gsf2.name() + ')',
256  dimless
257  )
258  );
259 
260  pow(tPow.ref(), gsf1, gsf2);
261 
262  tgsf2.clear();
263 
264  return tPow;
265 }
266 
267 
268 TEMPLATE2
269 tmp<GeometricField<scalar, GeoMesh, Field>> pow
270 (
271  const tmp<GeometricField<scalar, GeoMesh, PrimitiveField1>>& tgsf1,
272  const tmp<GeometricField<scalar, GeoMesh, PrimitiveField2>>& tgsf2
273 )
274 {
275  const GeometricField<scalar, GeoMesh, PrimitiveField1>& gsf1 = tgsf1();
276  const GeometricField<scalar, GeoMesh, PrimitiveField2>& gsf2 = tgsf2();
277 
278  if (!gsf1.dimensions().dimensionless())
279  {
280  FatalErrorInFunction
281  << "Base field is not dimensionless: " << gsf1.dimensions()
282  << exit(FatalError);
283  }
284 
285  if (!gsf2.dimensions().dimensionless())
286  {
287  FatalErrorInFunction
288  << "Exponent field is not dimensionless: " << gsf2.dimensions()
289  << exit(FatalError);
290  }
291 
292  tmp<GeometricField<scalar, GeoMesh, Field>> tPow
293  (
294  reuseTmpTmpGeometricField
295  <
296  scalar,
297  scalar,
298  scalar,
299  GeoMesh,
300  PrimitiveField1,
301  PrimitiveField2
302  >::New
303  (
304  tgsf1,
305  tgsf2,
306  "pow(" + gsf1.name() + ',' + gsf2.name() + ')',
307  dimless
308  )
309  );
310 
311  pow(tPow.ref(), gsf1, gsf2);
312 
313  tgsf1.clear();
314  tgsf2.clear();
315 
316  return tPow;
317 }
318 
319 
320 TEMPLATE2
321 void pow
322 (
323  GeometricField<scalar, GeoMesh, PrimitiveField1>& tPow,
324  const GeometricField<scalar, GeoMesh, PrimitiveField2>& gsf,
325  const dimensioned<scalar>& ds
326 )
327 {
328  pow(tPow.primitiveFieldRef(), gsf.primitiveField(), ds.value());
329  pow(tPow.boundaryFieldRef(), gsf.boundaryField(), ds.value());
330 }
331 
332 
333 TEMPLATE
334 tmp<GeometricField<scalar, GeoMesh, Field>> pow
335 (
336  const GeometricField<scalar, GeoMesh, PrimitiveField>& gsf,
337  const dimensionedScalar& ds
338 )
339 {
340  if (!ds.dimensions().dimensionless())
341  {
342  FatalErrorInFunction
343  << "Exponent is not dimensionless: " << ds.dimensions()
344  << exit(FatalError);
345  }
346 
347  tmp<GeometricField<scalar, GeoMesh, Field>> tPow
348  (
349  GeometricField<scalar, GeoMesh, Field>::New
350  (
351  "pow(" + gsf.name() + ',' + ds.name() + ')',
352  gsf.mesh(),
353  pow(gsf.dimensions(), ds)
354  )
355  );
356 
357  pow(tPow.ref(), gsf, ds);
358 
359  return tPow;
360 }
361 
362 
363 TEMPLATE
364 tmp<GeometricField<scalar, GeoMesh, Field>> pow
365 (
366  const tmp<GeometricField<scalar, GeoMesh, PrimitiveField>>& tgsf,
367  const dimensionedScalar& ds
368 )
369 {
370  if (!ds.dimensions().dimensionless())
371  {
372  FatalErrorInFunction
373  << "Exponent is not dimensionless: " << ds.dimensions()
374  << exit(FatalError);
375  }
376 
377  const GeometricField<scalar, GeoMesh, PrimitiveField>& gsf = tgsf();
378 
379  tmp<GeometricField<scalar, GeoMesh, Field>> tPow
380  (
381  reuseTmpGeometricField<scalar, scalar, GeoMesh, PrimitiveField>::New
382  (
383  tgsf,
384  "pow(" + gsf.name() + ',' + ds.name() + ')',
385  pow(gsf.dimensions(), ds)
386  )
387  );
388 
389  pow(tPow.ref(), gsf, ds);
390 
391  tgsf.clear();
392 
393  return tPow;
394 }
395 
396 
397 TEMPLATE
398 tmp<GeometricField<scalar, GeoMesh, Field>> pow
399 (
400  const GeometricField<scalar, GeoMesh, PrimitiveField>& gsf,
401  const scalar& s
402 )
403 {
404  return pow(gsf, dimensionedScalar(s));
405 }
406 
407 
408 TEMPLATE
409 tmp<GeometricField<scalar, GeoMesh, Field>> pow
410 (
411  const tmp<GeometricField<scalar, GeoMesh, PrimitiveField>>& tgsf,
412  const scalar& s
413 )
414 {
415  return pow(tgsf, dimensionedScalar(s));
416 }
417 
418 
419 TEMPLATE2
420 void pow
421 (
422  GeometricField<scalar, GeoMesh, PrimitiveField1>& tPow,
423  const dimensioned<scalar>& ds,
424  const GeometricField<scalar, GeoMesh, PrimitiveField2>& gsf
425 )
426 {
427  pow(tPow.primitiveFieldRef(), ds.value(), gsf.primitiveField());
428  pow(tPow.boundaryFieldRef(), ds.value(), gsf.boundaryField());
429 }
430 
431 
432 TEMPLATE
433 tmp<GeometricField<scalar, GeoMesh, Field>> pow
434 (
435  const dimensionedScalar& ds,
436  const GeometricField<scalar, GeoMesh, PrimitiveField>& gsf
437 )
438 {
439  if (!ds.dimensions().dimensionless())
440  {
441  FatalErrorInFunction
442  << "Base scalar is not dimensionless: " << ds.dimensions()
443  << exit(FatalError);
444  }
445 
446  if (!gsf.dimensions().dimensionless())
447  {
448  FatalErrorInFunction
449  << "Exponent field is not dimensionless: " << gsf.dimensions()
450  << exit(FatalError);
451  }
452 
453  tmp<GeometricField<scalar, GeoMesh, Field>> tPow
454  (
455  GeometricField<scalar, GeoMesh, Field>::New
456  (
457  "pow(" + ds.name() + ',' + gsf.name() + ')',
458  gsf.mesh(),
459  dimless
460  )
461  );
462 
463  pow(tPow.ref(), ds, gsf);
464 
465  return tPow;
466 }
467 
468 
469 TEMPLATE
470 tmp<GeometricField<scalar, GeoMesh, Field>> pow
471 (
472  const dimensionedScalar& ds,
473  const tmp<GeometricField<scalar, GeoMesh, PrimitiveField>>& tgsf
474 )
475 {
476  const GeometricField<scalar, GeoMesh, PrimitiveField>& gsf = tgsf();
477 
478  if (!ds.dimensions().dimensionless())
479  {
480  FatalErrorInFunction
481  << "Base scalar is not dimensionless: " << ds.dimensions()
482  << exit(FatalError);
483  }
484 
485  if (!gsf.dimensions().dimensionless())
486  {
487  FatalErrorInFunction
488  << "Exponent field is not dimensionless: " << gsf.dimensions()
489  << exit(FatalError);
490  }
491 
492  tmp<GeometricField<scalar, GeoMesh, Field>> tPow
493  (
494  reuseTmpGeometricField<scalar, scalar, GeoMesh, PrimitiveField>::New
495  (
496  tgsf,
497  "pow(" + ds.name() + ',' + gsf.name() + ')',
498  dimless
499  )
500  );
501 
502  pow(tPow.ref(), ds, gsf);
503 
504  tgsf.clear();
505 
506  return tPow;
507 }
508 
509 
510 TEMPLATE
511 tmp<GeometricField<scalar, GeoMesh, Field>> pow
512 (
513  const scalar& s,
514  const GeometricField<scalar, GeoMesh, PrimitiveField>& gsf
515 )
516 {
517  return pow(dimensionedScalar(s), gsf);
518 }
519 
520 
521 TEMPLATE
522 tmp<GeometricField<scalar, GeoMesh, Field>> pow
523 (
524  const scalar& s,
525  const tmp<GeometricField<scalar, GeoMesh, PrimitiveField>>& tgsf
526 )
527 {
528  return pow(dimensionedScalar(s), tgsf);
529 }
530 
531 
532 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
533 
534 TEMPLATE3
535 void atan2
536 (
537  GeometricField<scalar, GeoMesh, PrimitiveField1>& Atan2,
538  const GeometricField<scalar, GeoMesh, PrimitiveField2>& gsf1,
539  const GeometricField<scalar, GeoMesh, PrimitiveField3>& gsf2
540 )
541 {
542  atan2
543  (
544  Atan2.primitiveFieldRef(),
545  gsf1.primitiveField(),
546  gsf2.primitiveField()
547  );
548  atan2
549  (
550  Atan2.boundaryFieldRef(),
551  gsf1.boundaryField(),
552  gsf2.boundaryField()
553  );
554 }
555 
556 
557 TEMPLATE2
558 tmp<GeometricField<scalar, GeoMesh, Field>> atan2
559 (
560  const GeometricField<scalar, GeoMesh, PrimitiveField1>& gsf1,
561  const GeometricField<scalar, GeoMesh, PrimitiveField2>& gsf2
562 )
563 {
564  tmp<GeometricField<scalar, GeoMesh, Field>> tAtan2
565  (
566  GeometricField<scalar, GeoMesh, Field>::New
567  (
568  "atan2(" + gsf1.name() + ',' + gsf2.name() + ')',
569  gsf1.mesh(),
570  atan2(gsf1.dimensions(), gsf2.dimensions())
571  )
572  );
573 
574  atan2(tAtan2.ref(), gsf1, gsf2);
575 
576  return tAtan2;
577 }
578 
579 
580 TEMPLATE2
581 tmp<GeometricField<scalar, GeoMesh, Field>> atan2
582 (
583  const tmp<GeometricField<scalar, GeoMesh, PrimitiveField1>>& tgsf1,
584  const GeometricField<scalar, GeoMesh, PrimitiveField2>& gsf2
585 )
586 {
587  const GeometricField<scalar, GeoMesh, PrimitiveField1>& gsf1 = tgsf1();
588 
589  tmp<GeometricField<scalar, GeoMesh, Field>> tAtan2
590  (
591  reuseTmpGeometricField
592  <scalar, scalar, GeoMesh, PrimitiveField1>::New
593  (
594  tgsf1,
595  "atan2(" + gsf1.name() + ',' + gsf2.name() + ')',
596  atan2(gsf1.dimensions(), gsf2.dimensions())
597  )
598  );
599 
600  atan2(tAtan2.ref(), gsf1, gsf2);
601 
602  tgsf1.clear();
603 
604  return tAtan2;
605 }
606 
607 
608 TEMPLATE2
609 tmp<GeometricField<scalar, GeoMesh, Field>> atan2
610 (
611  const GeometricField<scalar, GeoMesh, PrimitiveField1>& gsf1,
612  const tmp<GeometricField<scalar, GeoMesh, PrimitiveField2>>& tgsf2
613 )
614 {
615  const GeometricField<scalar, GeoMesh, PrimitiveField2>& gsf2 = tgsf2();
616 
617  tmp<GeometricField<scalar, GeoMesh, Field>> tAtan2
618  (
619  reuseTmpGeometricField
620  <scalar, scalar, GeoMesh, PrimitiveField2>::New
621  (
622  tgsf2,
623  "atan2(" + gsf1.name() + ',' + gsf2.name() + ')',
624  atan2( gsf1.dimensions(), gsf2.dimensions())
625  )
626  );
627 
628  atan2(tAtan2.ref(), gsf1, gsf2);
629 
630  tgsf2.clear();
631 
632  return tAtan2;
633 }
634 
635 
636 TEMPLATE2
637 tmp<GeometricField<scalar, GeoMesh, Field>> atan2
638 (
639  const tmp<GeometricField<scalar, GeoMesh, PrimitiveField1>>& tgsf1,
640  const tmp<GeometricField<scalar, GeoMesh, PrimitiveField2>>& tgsf2
641 )
642 {
643  const GeometricField<scalar, GeoMesh, PrimitiveField1>& gsf1 = tgsf1();
644  const GeometricField<scalar, GeoMesh, PrimitiveField2>& gsf2 = tgsf2();
645 
646  tmp<GeometricField<scalar, GeoMesh, Field>> tAtan2
647  (
648  reuseTmpTmpGeometricField
649  <
650  scalar,
651  scalar,
652  scalar,
653  GeoMesh,
654  PrimitiveField1,
655  PrimitiveField2
656  >::New
657  (
658  tgsf1,
659  tgsf2,
660  "atan2(" + gsf1.name() + ',' + gsf2.name() + ')',
661  atan2(gsf1.dimensions(), gsf2.dimensions())
662  )
663  );
664 
665  atan2(tAtan2.ref(), gsf1, gsf2);
666 
667  tgsf1.clear();
668  tgsf2.clear();
669 
670  return tAtan2;
671 }
672 
673 
674 TEMPLATE2
675 void atan2
676 (
677  GeometricField<scalar, GeoMesh, PrimitiveField1>& tAtan2,
678  const GeometricField<scalar, GeoMesh, PrimitiveField2>& gsf,
679  const dimensioned<scalar>& ds
680 )
681 {
682  atan2(tAtan2.primitiveFieldRef(), gsf.primitiveField(), ds.value());
683  atan2(tAtan2.boundaryFieldRef(), gsf.boundaryField(), ds.value());
684 }
685 
686 
687 TEMPLATE
688 tmp<GeometricField<scalar, GeoMesh, Field>> atan2
689 (
690  const GeometricField<scalar, GeoMesh, PrimitiveField>& gsf,
691  const dimensionedScalar& ds
692 )
693 {
694  tmp<GeometricField<scalar, GeoMesh, Field>> tAtan2
695  (
696  GeometricField<scalar, GeoMesh, Field>::New
697  (
698  "atan2(" + gsf.name() + ',' + ds.name() + ')',
699  gsf.mesh(),
700  atan2(gsf.dimensions(), ds)
701  )
702  );
703 
704  atan2(tAtan2.ref(), gsf, ds);
705 
706  return tAtan2;
707 }
708 
709 
710 TEMPLATE
711 tmp<GeometricField<scalar, GeoMesh, Field>> atan2
712 (
713  const tmp<GeometricField<scalar, GeoMesh, PrimitiveField>>& tgsf,
714  const dimensionedScalar& ds
715 )
716 {
717  const GeometricField<scalar, GeoMesh, PrimitiveField>& gsf = tgsf();
718 
719  tmp<GeometricField<scalar, GeoMesh, Field>> tAtan2
720  (
721  reuseTmpGeometricField<scalar, scalar, GeoMesh, PrimitiveField>::New
722  (
723  tgsf,
724  "atan2(" + gsf.name() + ',' + ds.name() + ')',
725  atan2(gsf.dimensions(), ds)
726  )
727  );
728 
729  atan2(tAtan2.ref(), gsf, ds);
730 
731  tgsf.clear();
732 
733  return tAtan2;
734 }
735 
736 
737 TEMPLATE
738 tmp<GeometricField<scalar, GeoMesh, Field>> atan2
739 (
740  const GeometricField<scalar, GeoMesh, PrimitiveField>& gsf,
741  const scalar& s
742 )
743 {
744  return atan2(gsf, dimensionedScalar(s));
745 }
746 
747 
748 TEMPLATE
749 tmp<GeometricField<scalar, GeoMesh, Field>> atan2
750 (
751  const tmp<GeometricField<scalar, GeoMesh, PrimitiveField>>& tgsf,
752  const scalar& s
753 )
754 {
755  return atan2(tgsf, dimensionedScalar(s));
756 }
757 
758 
759 TEMPLATE2
760 void atan2
761 (
762  GeometricField<scalar, GeoMesh, PrimitiveField1>& tAtan2,
763  const dimensioned<scalar>& ds,
764  const GeometricField<scalar, GeoMesh, PrimitiveField2>& gsf
765 )
766 {
767  atan2(tAtan2.primitiveFieldRef(), ds.value(), gsf.primitiveField());
768  atan2(tAtan2.boundaryFieldRef(), ds.value(), gsf.boundaryField());
769 }
770 
771 
772 TEMPLATE
773 tmp<GeometricField<scalar, GeoMesh, Field>> atan2
774 (
775  const dimensionedScalar& ds,
776  const GeometricField<scalar, GeoMesh, PrimitiveField>& gsf
777 )
778 {
779  tmp<GeometricField<scalar, GeoMesh, Field>> tAtan2
780  (
781  GeometricField<scalar, GeoMesh, Field>::New
782  (
783  "atan2(" + ds.name() + ',' + gsf.name() + ')',
784  gsf.mesh(),
785  atan2(ds, gsf.dimensions())
786  )
787  );
788 
789  atan2(tAtan2.ref(), ds, gsf);
790 
791  return tAtan2;
792 }
793 
794 
795 TEMPLATE
796 tmp<GeometricField<scalar, GeoMesh, Field>> atan2
797 (
798  const dimensionedScalar& ds,
799  const tmp<GeometricField<scalar, GeoMesh, PrimitiveField>>& tgsf
800 )
801 {
802  const GeometricField<scalar, GeoMesh, PrimitiveField>& gsf =tgsf();
803 
804  tmp<GeometricField<scalar, GeoMesh, Field>> tAtan2
805  (
806  reuseTmpGeometricField<scalar, scalar, GeoMesh, PrimitiveField>::New
807  (
808  tgsf,
809  "atan2(" + ds.name() + ',' + gsf.name() + ')',
810  atan2(ds, gsf.dimensions())
811  )
812  );
813 
814  atan2(tAtan2.ref(), ds, gsf);
815 
816  tgsf.clear();
817 
818  return tAtan2;
819 }
820 
821 
822 TEMPLATE
823 tmp<GeometricField<scalar, GeoMesh, Field>> atan2
824 (
825  const scalar& s,
826  const GeometricField<scalar, GeoMesh, PrimitiveField>& gsf
827 )
828 {
829  return atan2(dimensionedScalar(s), gsf);
830 }
831 
832 
833 TEMPLATE
834 tmp<GeometricField<scalar, GeoMesh, Field>> atan2
835 (
836  const scalar& s,
837  const tmp<GeometricField<scalar, GeoMesh, PrimitiveField>>& tgsf
838 )
839 {
840  return atan2(dimensionedScalar(s), tgsf);
841 }
842 
843 
844 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
845 
846 UNARY_FUNCTION(scalar, scalar, pow3, pow3)
847 UNARY_FUNCTION(scalar, scalar, pow4, pow4)
848 UNARY_FUNCTION(scalar, scalar, pow5, pow5)
849 UNARY_FUNCTION(scalar, scalar, pow6, pow6)
850 UNARY_FUNCTION(scalar, scalar, pow025, pow025)
851 UNARY_FUNCTION(scalar, scalar, sqrt, sqrt)
852 UNARY_FUNCTION(scalar, scalar, cbrt, cbrt)
853 UNARY_FUNCTION(scalar, scalar, sign, sign)
854 UNARY_FUNCTION(scalar, scalar, pos, pos)
855 UNARY_FUNCTION(scalar, scalar, pos0, pos0)
856 UNARY_FUNCTION(scalar, scalar, neg, neg)
857 UNARY_FUNCTION(scalar, scalar, neg0, neg0)
858 UNARY_FUNCTION(scalar, scalar, posPart, posPart)
859 UNARY_FUNCTION(scalar, scalar, negPart, negPart)
860 
861 UNARY_FUNCTION(scalar, scalar, exp, trans)
862 UNARY_FUNCTION(scalar, scalar, log, trans)
863 UNARY_FUNCTION(scalar, scalar, log10, trans)
864 UNARY_FUNCTION(scalar, scalar, sin, trans)
865 UNARY_FUNCTION(scalar, scalar, cos, trans)
866 UNARY_FUNCTION(scalar, scalar, tan, trans)
867 UNARY_FUNCTION(scalar, scalar, asin, trans)
868 UNARY_FUNCTION(scalar, scalar, acos, trans)
869 UNARY_FUNCTION(scalar, scalar, atan, trans)
870 UNARY_FUNCTION(scalar, scalar, sinh, trans)
871 UNARY_FUNCTION(scalar, scalar, cosh, trans)
872 UNARY_FUNCTION(scalar, scalar, tanh, trans)
873 UNARY_FUNCTION(scalar, scalar, asinh, trans)
874 UNARY_FUNCTION(scalar, scalar, acosh, trans)
875 UNARY_FUNCTION(scalar, scalar, atanh, trans)
876 UNARY_FUNCTION(scalar, scalar, erf, trans)
877 UNARY_FUNCTION(scalar, scalar, erfc, trans)
878 UNARY_FUNCTION(scalar, scalar, lgamma, trans)
879 UNARY_FUNCTION(scalar, scalar, j0, trans)
880 UNARY_FUNCTION(scalar, scalar, j1, trans)
881 UNARY_FUNCTION(scalar, scalar, y0, trans)
882 UNARY_FUNCTION(scalar, scalar, y1, trans)
883 
884 
885 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
886 
887 #define BesselFunc(func) \
888  \
889 TEMPLATE2 \
890 void func \
891 ( \
892  GeometricField<scalar, GeoMesh, PrimitiveField1>& gsf, \
893  const int n, \
894  const GeometricField<scalar, GeoMesh, PrimitiveField2>& gsf1 \
895 ) \
896 { \
897  func(gsf.primitiveFieldRef(), n, gsf1.primitiveField()); \
898  func(gsf.boundaryFieldRef(), n, gsf1.boundaryField()); \
899 } \
900  \
901 TEMPLATE \
902 tmp<GeometricField<scalar, GeoMesh, Field>> func \
903 ( \
904  const int n, \
905  const GeometricField<scalar, GeoMesh, PrimitiveField>& gsf \
906 ) \
907 { \
908  if (!gsf.dimensions().dimensionless()) \
909  { \
910  FatalErrorInFunction \
911  << "gsf not dimensionless" \
912  << abort(FatalError); \
913  } \
914  \
915  tmp<GeometricField<scalar, GeoMesh, Field>> tFunc \
916  ( \
917  GeometricField<scalar, GeoMesh, Field>::New \
918  ( \
919  #func "(" + gsf.name() + ')', \
920  gsf.mesh(), \
921  dimless \
922  ) \
923  ); \
924  \
925  func(tFunc.ref(), n, gsf); \
926  \
927  return tFunc; \
928 } \
929  \
930 TEMPLATE \
931 tmp<GeometricField<scalar, GeoMesh, Field>> func \
932 ( \
933  const int n, \
934  const tmp<GeometricField<scalar, GeoMesh, PrimitiveField>>& tgsf \
935 ) \
936 { \
937  const GeometricField<scalar, GeoMesh, PrimitiveField>& gsf = tgsf(); \
938  \
939  if (!gsf.dimensions().dimensionless()) \
940  { \
941  FatalErrorInFunction \
942  << " : gsf not dimensionless" \
943  << abort(FatalError); \
944  } \
945  \
946  tmp<GeometricField<scalar, GeoMesh, Field>> tFunc \
947  ( \
948  reuseTmpGeometricField<scalar, scalar, GeoMesh, PrimitiveField>::New \
949  ( \
950  tgsf, \
951  #func "(" + gsf.name() + ')', \
952  dimless \
953  ) \
954  ); \
955  \
956  func(tFunc.ref(), n, gsf); \
957  \
958  tgsf.clear(); \
959  \
960  return tFunc; \
961 }
962 
963 BesselFunc(jn)
964 BesselFunc(yn)
965 
966 #undef BesselFunc
967 
968 
969 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
970 
971 } // End namespace Foam
972 
973 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
974 
975 #include "undefFieldFunctionsM.H"
976 
977 // ************************************************************************* //
BINARY_TYPE_OPERATOR
#define BINARY_TYPE_OPERATOR(ReturnType, Type1, Type2, Op, OpName, OpFunc)
Definition: DimensionedFieldFunctionsM.C:778
TEMPLATE2
#define TEMPLATE2
Definition: GeometricScalarField.C:34
TEMPLATE
#define TEMPLATE
Definition: GeometricScalarField.C:28
TEMPLATE3
#define TEMPLATE3
Definition: GeometricScalarField.C:41
BesselFunc
#define BesselFunc(func)
Definition: GeometricScalarField.C:887
GeometricScalarField.H
Scalar specific part of the implementation of GeometricField.
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::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::GeoMesh
Generic mesh wrapper used by volMesh, surfaceMesh, pointMesh etc.
Definition: GeoMesh.H:47
Foam::GeometricField
Generic GeometricField class.
Definition: GeometricField.H:77
Foam::GeometricField::boundaryField
const Boundary & boundaryField() const
Return const-reference to the boundary field.
Definition: GeometricFieldI.H:59
Foam::GeometricField::primitiveFieldRef
Internal::FieldType & primitiveFieldRef()
Return a reference to the primitive field.
Definition: GeometricField.C:1387
Foam::GeometricField::boundaryFieldRef
Boundary & boundaryFieldRef()
Return a reference to the boundary field.
Definition: GeometricField.C:1398
Foam::GeometricField::primitiveField
const Internal::FieldType & primitiveField() const
Return a const-reference to the primitive field.
Definition: GeometricFieldI.H:50
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