FreeFOAM The Cross-Platform CFD Toolkit
DimensionedScalarField.C
Go to the documentation of this file.
1 /*---------------------------------------------------------------------------*\
2  ========= |
3  \\ / F ield | OpenFOAM: The Open Source CFD Toolbox
4  \\ / O peration |
5  \\ / A nd | Copyright (C) 1991-2010 OpenCFD Ltd.
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 
27 
28 #define TEMPLATE template<class GeoMesh>
30 
31 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
32 
33 namespace Foam
34 {
35 
36 // * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
37 
38 template<class GeoMesh>
39 tmp<DimensionedField<scalar, GeoMesh> > stabilise
40 (
42  const dimensioned<scalar>& ds
43 )
44 {
46  (
48  (
49  IOobject
50  (
51  "stabilise(" + dsf.name() + ',' + ds.name() + ')',
52  dsf.instance(),
53  dsf.db()
54  ),
55  dsf.mesh(),
56  dsf.dimensions() + ds.dimensions()
57  )
58  );
59 
60  stabilise(tRes().field(), dsf.field(), ds.value());
61 
62  return tRes;
63 }
64 
65 
66 template<class GeoMesh>
67 tmp<DimensionedField<scalar, GeoMesh> > stabilise
68 (
70  const dimensioned<scalar>& ds
71 )
72 {
73  const DimensionedField<scalar, GeoMesh>& dsf = tdsf();
74 
77  (
78  tdsf,
79  "stabilise(" + dsf.name() + ',' + ds.name() + ')',
80  dsf.dimensions() + ds.dimensions()
81  );
82 
83  stabilise(tRes().field(), dsf.field(), ds.value());
84 
86 
87  return tRes;
88 }
89 
90 
91 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
92 
93 BINARY_TYPE_OPERATOR(scalar, scalar, scalar, +, '+', add)
94 BINARY_TYPE_OPERATOR(scalar, scalar, scalar, -, '-', subtract)
95 
96 BINARY_OPERATOR(scalar, scalar, scalar, *, '*', multiply)
97 BINARY_OPERATOR(scalar, scalar, scalar, /, '|', divide)
98 
99 BINARY_TYPE_OPERATOR_SF(scalar, scalar, scalar, /, '|', divide)
100 
101 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
102 
103 template<class GeoMesh>
104 tmp<DimensionedField<scalar, GeoMesh> > pow
105 (
106  const DimensionedField<scalar, GeoMesh>& dsf1,
107  const DimensionedField<scalar, GeoMesh>& dsf2
108 )
109 {
111  (
113  (
114  IOobject
115  (
116  "pow(" + dsf1.name() + ',' + dsf2.name() + ')',
117  dsf1.instance(),
118  dsf1.db()
119  ),
120  dsf1.mesh(),
121  pow
122  (
123  dsf1.dimensions(),
124  dimensionedScalar("1", 1.0, dsf2.dimensions())
125  )
126  )
127  );
128 
129  pow(tPow().field(), dsf1.field(), dsf2.field());
130 
131  return tPow;
132 }
133 
134 
135 template<class GeoMesh>
136 tmp<DimensionedField<scalar, GeoMesh> > pow
137 (
138  const tmp<DimensionedField<scalar, GeoMesh> >& tdsf1,
140 )
141 {
142  const DimensionedField<scalar, GeoMesh>& dsf1 = tdsf1();
143 
146  (
147  tdsf1,
148  "pow(" + dsf1.name() + ',' + dsf2.name() + ')',
149  pow
150  (
151  dsf1.dimensions(),
152  dimensionedScalar("1", 1.0, dsf2.dimensions())
153  )
154  );
155 
156  pow(tPow().field(), dsf1.field(), dsf2.field());
157 
159 
160  return tPow;
161 }
162 
163 
164 template<class GeoMesh>
165 tmp<DimensionedField<scalar, GeoMesh> > pow
166 (
169 )
170 {
171  const DimensionedField<scalar, GeoMesh>& dsf2 = tdsf2();
172 
175  (
176  tdsf2,
177  "pow(" + dsf1.name() + ',' + dsf2.name() + ')',
178  pow
179  (
180  dsf1.dimensions(),
181  dimensionedScalar("1", 1.0, dsf2.dimensions())
182  )
183  );
184 
185  pow(tPow().field(), dsf1.field(), dsf2.field());
186 
188 
189  return tPow;
190 }
191 
192 template<class GeoMesh>
193 tmp<DimensionedField<scalar, GeoMesh> > pow
194 (
195  const tmp<DimensionedField<scalar, GeoMesh> >& tdsf1,
197 )
198 {
199  const DimensionedField<scalar, GeoMesh>& dsf1 = tdsf1();
200  const DimensionedField<scalar, GeoMesh>& dsf2 = tdsf2();
201 
204  New
205  (
206  tdsf1,
207  tdsf2,
208  "pow(" + dsf1.name() + ',' + dsf2.name() + ')',
209  pow
210  (
211  dsf1.dimensions(),
212  dimensionedScalar("1", 1.0, dsf2.dimensions())
213  )
214  );
215 
216  pow(tPow().field(), dsf1.field(), dsf2.field());
217 
219  (
220  tdsf1,
221  tdsf2
222  );
223 
224  return tPow;
225 }
226 
227 
228 template<class GeoMesh>
229 tmp<DimensionedField<scalar, GeoMesh> > pow
230 (
232  const dimensionedScalar& ds
233 )
234 {
236  (
238  (
239  IOobject
240  (
241  "pow(" + dsf.name() + ',' + ds.name() + ')',
242  dsf.instance(),
243  dsf.db()
244  ),
245  dsf.mesh(),
246  pow(dsf.dimensions(), ds)
247  )
248  );
249 
250  pow(tPow().field(), dsf.field(), ds.value());
251 
252  return tPow;
253 }
254 
255 template<class GeoMesh>
256 tmp<DimensionedField<scalar, GeoMesh> > pow
257 (
259  const dimensionedScalar& ds
260 )
261 {
262  const DimensionedField<scalar, GeoMesh>& dsf = tdsf();
263 
266  (
267  tdsf,
268  "pow(" + dsf.name() + ',' + ds.name() + ')',
269  pow(dsf.dimensions(), ds)
270  );
271 
272  pow(tPow().field(), dsf.field(), ds.value());
273 
275 
276  return tPow;
277 }
278 
279 template<class GeoMesh>
280 tmp<DimensionedField<scalar, GeoMesh> > pow
281 (
283  const scalar& s
284 )
285 {
286  return pow(dsf, dimensionedScalar(s));
287 }
288 
289 template<class GeoMesh>
290 tmp<DimensionedField<scalar, GeoMesh> > pow
291 (
293  const scalar& s
294 )
295 {
296  return pow(tdsf, dimensionedScalar(s));
297 }
298 
299 
300 template<class GeoMesh>
301 tmp<DimensionedField<scalar, GeoMesh> > pow
302 (
303  const dimensionedScalar& ds,
305 )
306 {
308  (
310  (
311  IOobject
312  (
313  "pow(" + ds.name() + ',' + dsf.name() + ')',
314  dsf.instance(),
315  dsf.db()
316  ),
317  dsf.mesh(),
318  pow(ds, dsf.dimensions())
319  )
320  );
321 
322  pow(tPow().field(), ds.value(), dsf.field());
323 
324  return tPow;
325 }
326 
327 
328 template<class GeoMesh>
329 tmp<DimensionedField<scalar, GeoMesh> > pow
330 (
331  const dimensionedScalar& ds,
333 )
334 {
335  const DimensionedField<scalar, GeoMesh>& dsf = tdsf();
336 
339  (
340  tdsf,
341  "pow(" + ds.name() + ',' + dsf.name() + ')',
342  pow(ds, dsf.dimensions())
343  );
344 
345  pow(tPow().field(), ds.value(), dsf.field());
346 
348 
349  return tPow;
350 }
351 
352 template<class GeoMesh>
353 tmp<DimensionedField<scalar, GeoMesh> > pow
354 (
355  const scalar& s,
357 )
358 {
359  return pow(dimensionedScalar(s), dsf);
360 }
361 
362 template<class GeoMesh>
363 tmp<DimensionedField<scalar, GeoMesh> > pow
364 (
365  const scalar& s,
367 )
368 {
369  return pow(dimensionedScalar(s), tdsf);
370 }
371 
372 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
373 
374 UNARY_FUNCTION(scalar, scalar, pow3, pow3)
375 UNARY_FUNCTION(scalar, scalar, pow4, pow4)
376 UNARY_FUNCTION(scalar, scalar, pow5, pow5)
377 UNARY_FUNCTION(scalar, scalar, pow6, pow6)
378 UNARY_FUNCTION(scalar, scalar, sqrt, sqrt)
379 UNARY_FUNCTION(scalar, scalar, sign, sign)
380 UNARY_FUNCTION(scalar, scalar, pos, pos)
381 UNARY_FUNCTION(scalar, scalar, neg, neg)
382 
383 UNARY_FUNCTION(scalar, scalar, exp, trans)
384 UNARY_FUNCTION(scalar, scalar, log, trans)
385 UNARY_FUNCTION(scalar, scalar, log10, trans)
386 UNARY_FUNCTION(scalar, scalar, sin, trans)
387 UNARY_FUNCTION(scalar, scalar, cos, trans)
388 UNARY_FUNCTION(scalar, scalar, tan, trans)
389 UNARY_FUNCTION(scalar, scalar, asin, trans)
390 UNARY_FUNCTION(scalar, scalar, acos, trans)
391 UNARY_FUNCTION(scalar, scalar, atan, trans)
392 UNARY_FUNCTION(scalar, scalar, sinh, trans)
393 UNARY_FUNCTION(scalar, scalar, cosh, trans)
394 UNARY_FUNCTION(scalar, scalar, tanh, trans)
395 UNARY_FUNCTION(scalar, scalar, asinh, trans)
396 UNARY_FUNCTION(scalar, scalar, acosh, trans)
397 UNARY_FUNCTION(scalar, scalar, atanh, trans)
398 UNARY_FUNCTION(scalar, scalar, erf, trans)
399 UNARY_FUNCTION(scalar, scalar, erfc, trans)
400 UNARY_FUNCTION(scalar, scalar, lgamma, trans)
401 UNARY_FUNCTION(scalar, scalar, j0, trans)
402 UNARY_FUNCTION(scalar, scalar, j1, trans)
403 UNARY_FUNCTION(scalar, scalar, y0, trans)
404 UNARY_FUNCTION(scalar, scalar, y1, trans)
405 
406 
407 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
408 
409 #define BesselFunc(func) \
410  \
411 template<class GeoMesh> \
412 tmp<DimensionedField<scalar, GeoMesh> > func \
413 ( \
414  const int n, \
415  const DimensionedField<scalar, GeoMesh>& dsf \
416 ) \
417 { \
418  if (!dsf.dimensions().dimensionless()) \
419  { \
420  FatalErrorIn \
421  ( \
422  #func"(const int n, " \
423  "const DimensionedField<scalar, GeoMesh>& dsf)" \
424  ) << "dsf not dimensionless" \
425  << abort(FatalError); \
426  } \
427  \
428  tmp<DimensionedField<scalar, GeoMesh> > tFunc \
429  ( \
430  new DimensionedField<scalar, GeoMesh> \
431  ( \
432  IOobject \
433  ( \
434  #func "(" + name(n) + ',' + dsf.name() + ')', \
435  dsf.instance(), \
436  dsf.db() \
437  ), \
438  dsf.mesh(), \
439  dimless \
440  ) \
441  ); \
442  \
443  func(tFunc().field(), n, dsf.field()); \
444  \
445  return tFunc; \
446 } \
447  \
448 template<class GeoMesh> \
449 tmp<DimensionedField<scalar, GeoMesh> > func \
450 ( \
451  const int n, \
452  const tmp<DimensionedField<scalar, GeoMesh> >& tdsf \
453 ) \
454 { \
455  const DimensionedField<scalar, GeoMesh>& dsf = tdsf(); \
456  \
457  if (!dsf.dimensions().dimensionless()) \
458  { \
459  FatalErrorIn \
460  ( \
461  #func"(const int n, " \
462  "const tmp<DimensionedField<scalar, GeoMesh> >& dsf)" \
463  ) << " : dsf not dimensionless" \
464  << abort(FatalError); \
465  } \
466  \
467  tmp<DimensionedField<scalar, GeoMesh> > tFunc \
468  ( \
469  reuseTmpDimensionedField<scalar, scalar, GeoMesh>::New \
470  ( \
471  tdsf, \
472  #func "(" + name(n) + ',' + dsf.name() + ')', \
473  dimless \
474  ) \
475  ); \
476  \
477  func(tFunc().field(), n, dsf.field()); \
478  \
479  reuseTmpDimensionedField<scalar, scalar, GeoMesh>::clear(tdsf); \
480  \
481  return tFunc; \
482 }
483 
486 
487 #undef BesselFunc
488 
489 
490 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
491 
492 } // End namespace Foam
493 
494 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
495 
497 
498 // ************************ vim: set sw=4 sts=4 et: ************************ //