src/OpenFOAM/fields/DimensionedFields/DimensionedScalarField/DimensionedScalarField.C

   1 /*---------------------------------------------------------------------------*\
   2   =========                 |
   3   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
   4    \\    /   O peration     |
   5     \\  /    A nd           | Copyright (C) 2004-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
  26 #include "DimensionedScalarField.H"
  27
  28 #define TEMPLATE template<class GeoMesh>
  29 #include "DimensionedFieldFunctionsM.C"
  30
  31 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
  32
  33 namespace Foam
  34 {
  35
  36 // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
  37
  38 template<class GeoMesh>
  39 tmp<DimensionedField<scalar, GeoMesh> > stabilise
  40 (
  41     const DimensionedField<scalar, GeoMesh>& dsf,
  42     const dimensioned<scalar>& ds
  43 )
  44 {
  45     tmp<DimensionedField<scalar, GeoMesh> > tRes
  46     (
  47         new DimensionedField<scalar, GeoMesh>
  48         (
  49             IOobject
  50             (
  51                 "stabilise(" + dsf.name() + ',' + ds.name() + ')',
  52                 dsf.instance(),
  53                 dsf.db()
  54             ),
  55             dsf.mesh(),
  56             dsf.dimensions() + ds.dimensions()
  57         )
  58     );
  59
  60     stabilise(tRes().field(), dsf.field(), ds.value());
  61
  62     return tRes;
  63 }
  64
  65
  66 template<class GeoMesh>
  67 tmp<DimensionedField<scalar, GeoMesh> > stabilise
  68 (
  69     const tmp<DimensionedField<scalar, GeoMesh> >& tdsf,
  70     const dimensioned<scalar>& ds
  71 )
  72 {
  73     const DimensionedField<scalar, GeoMesh>& dsf = tdsf();
  74
  75     tmp<DimensionedField<scalar, GeoMesh> > tRes =
  76         reuseTmpDimensionedField<scalar, scalar, GeoMesh>::New
  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
  85     reuseTmpDimensionedField<scalar, scalar, GeoMesh>::clear(tdsf);
  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 {
 110     tmp<DimensionedField<scalar, GeoMesh> > tPow
 111     (
 112         new DimensionedField<scalar, GeoMesh>
 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,
 139     const DimensionedField<scalar, GeoMesh>& dsf2
 140 )
 141 {
 142     const DimensionedField<scalar, GeoMesh>& dsf1 = tdsf1();
 143
 144     tmp<DimensionedField<scalar, GeoMesh> > tPow =
 145         reuseTmpDimensionedField<scalar, scalar, GeoMesh>::New
 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
 158     reuseTmpDimensionedField<scalar, scalar, GeoMesh>::clear(tdsf1);
 159
 160     return tPow;
 161 }
 162
 163
 164 template<class GeoMesh>
 165 tmp<DimensionedField<scalar, GeoMesh> > pow
 166 (
 167     const DimensionedField<scalar, GeoMesh>& dsf1,
 168     const tmp<DimensionedField<scalar, GeoMesh> >& tdsf2
 169 )
 170 {
 171     const DimensionedField<scalar, GeoMesh>& dsf2 = tdsf2();
 172
 173     tmp<DimensionedField<scalar, GeoMesh> > tPow =
 174         reuseTmpDimensionedField<scalar, scalar, GeoMesh>::New
 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
 187     reuseTmpDimensionedField<scalar, scalar, GeoMesh>::clear(tdsf2);
 188
 189     return tPow;
 190 }
 191
 192 template<class GeoMesh>
 193 tmp<DimensionedField<scalar, GeoMesh> > pow
 194 (
 195     const tmp<DimensionedField<scalar, GeoMesh> >& tdsf1,
 196     const tmp<DimensionedField<scalar, GeoMesh> >& tdsf2
 197 )
 198 {
 199     const DimensionedField<scalar, GeoMesh>& dsf1 = tdsf1();
 200     const DimensionedField<scalar, GeoMesh>& dsf2 = tdsf2();
 201
 202     tmp<DimensionedField<scalar, GeoMesh> > tPow =
 203         reuseTmpTmpDimensionedField<scalar, scalar, scalar, scalar, GeoMesh>::
 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
 218     reuseTmpTmpDimensionedField<scalar, scalar, scalar, scalar, GeoMesh>::clear
 219     (
 220         tdsf1,
 221         tdsf2
 222     );
 223
 224     return tPow;
 225 }
 226
 227
 228 template<class GeoMesh>
 229 tmp<DimensionedField<scalar, GeoMesh> > pow
 230 (
 231     const DimensionedField<scalar, GeoMesh>& dsf,
 232     const dimensionedScalar& ds
 233 )
 234 {
 235     tmp<DimensionedField<scalar, GeoMesh> > tPow
 236     (
 237         new DimensionedField<scalar, GeoMesh>
 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 (
 258     const tmp<DimensionedField<scalar, GeoMesh> >& tdsf,
 259     const dimensionedScalar& ds
 260 )
 261 {
 262     const DimensionedField<scalar, GeoMesh>& dsf = tdsf();
 263
 264     tmp<DimensionedField<scalar, GeoMesh> > tPow =
 265         reuseTmpDimensionedField<scalar, scalar, GeoMesh>::New
 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
 274     reuseTmpDimensionedField<scalar, scalar, GeoMesh>::clear(tdsf);
 275
 276     return tPow;
 277 }
 278
 279 template<class GeoMesh>
 280 tmp<DimensionedField<scalar, GeoMesh> > pow
 281 (
 282     const DimensionedField<scalar, GeoMesh>& dsf,
 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 (
 292     const tmp<DimensionedField<scalar, GeoMesh> >& tdsf,
 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,
 304     const DimensionedField<scalar, GeoMesh>& dsf
 305 )
 306 {
 307     tmp<DimensionedField<scalar, GeoMesh> > tPow
 308     (
 309         new DimensionedField<scalar, GeoMesh>
 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,
 332     const tmp<DimensionedField<scalar, GeoMesh> >& tdsf
 333 )
 334 {
 335     const DimensionedField<scalar, GeoMesh>& dsf = tdsf();
 336
 337     tmp<DimensionedField<scalar, GeoMesh> > tPow =
 338         reuseTmpDimensionedField<scalar, scalar, GeoMesh>::New
 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
 347     reuseTmpDimensionedField<scalar, scalar, GeoMesh>::clear(tdsf);
 348
 349     return tPow;
 350 }
 351
 352 template<class GeoMesh>
 353 tmp<DimensionedField<scalar, GeoMesh> > pow
 354 (
 355     const scalar& s,
 356     const DimensionedField<scalar, GeoMesh>& dsf
 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,
 366     const tmp<DimensionedField<scalar, GeoMesh> >& tdsf
 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, pow025, pow025)
 379 UNARY_FUNCTION(scalar, scalar, sqrt, sqrt)
 380 UNARY_FUNCTION(scalar, scalar, sign, sign)
 381 UNARY_FUNCTION(scalar, scalar, pos, pos)
 382 UNARY_FUNCTION(scalar, scalar, neg, neg)
 383
 384 UNARY_FUNCTION(scalar, scalar, exp, trans)
 385 UNARY_FUNCTION(scalar, scalar, log, trans)
 386 UNARY_FUNCTION(scalar, scalar, log10, trans)
 387 UNARY_FUNCTION(scalar, scalar, sin, trans)
 388 UNARY_FUNCTION(scalar, scalar, cos, trans)
 389 UNARY_FUNCTION(scalar, scalar, tan, trans)
 390 UNARY_FUNCTION(scalar, scalar, asin, trans)
 391 UNARY_FUNCTION(scalar, scalar, acos, trans)
 392 UNARY_FUNCTION(scalar, scalar, atan, trans)
 393 UNARY_FUNCTION(scalar, scalar, sinh, trans)
 394 UNARY_FUNCTION(scalar, scalar, cosh, trans)
 395 UNARY_FUNCTION(scalar, scalar, tanh, trans)
 396 UNARY_FUNCTION(scalar, scalar, asinh, trans)
 397 UNARY_FUNCTION(scalar, scalar, acosh, trans)
 398 UNARY_FUNCTION(scalar, scalar, atanh, trans)
 399 UNARY_FUNCTION(scalar, scalar, erf, trans)
 400 UNARY_FUNCTION(scalar, scalar, erfc, trans)
 401 UNARY_FUNCTION(scalar, scalar, lgamma, trans)
 402 UNARY_FUNCTION(scalar, scalar, j0, trans)
 403 UNARY_FUNCTION(scalar, scalar, j1, trans)
 404 UNARY_FUNCTION(scalar, scalar, y0, trans)
 405 UNARY_FUNCTION(scalar, scalar, y1, trans)
 406
 407
 408 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 409
 410 #define BesselFunc(func)                                                    \
 411                                                                             \
 412 template<class GeoMesh>                                                     \
 413 tmp<DimensionedField<scalar, GeoMesh> > func                                \
 414 (                                                                           \
 415     const int n,                                                            \
 416     const DimensionedField<scalar, GeoMesh>& dsf                            \
 417 )                                                                           \
 418 {                                                                           \
 419     if (!dsf.dimensions().dimensionless())                                  \
 420     {                                                                       \
 421         FatalErrorIn                                                        \
 422         (                                                                   \
 423             #func"(const int n, "                                           \
 424             "const DimensionedField<scalar, GeoMesh>& dsf)"                 \
 425         )   << "dsf not dimensionless"                                      \
 426             << abort(FatalError);                                           \
 427     }                                                                       \
 428                                                                             \
 429     tmp<DimensionedField<scalar, GeoMesh> > tFunc                           \
 430     (                                                                       \
 431         new DimensionedField<scalar, GeoMesh>                               \
 432         (                                                                   \
 433             IOobject                                                        \
 434             (                                                               \
 435                 #func "(" + name(n) + ',' + dsf.name() + ')',               \
 436                 dsf.instance(),                                             \
 437                 dsf.db()                                                    \
 438             ),                                                              \
 439             dsf.mesh(),                                                     \
 440             dimless                                                         \
 441         )                                                                   \
 442     );                                                                      \
 443                                                                             \
 444     func(tFunc().field(), n, dsf.field());                                  \
 445                                                                             \
 446     return tFunc;                                                           \
 447 }                                                                           \
 448                                                                             \
 449 template<class GeoMesh>                                                     \
 450 tmp<DimensionedField<scalar, GeoMesh> > func                                \
 451 (                                                                           \
 452     const int n,                                                            \
 453     const tmp<DimensionedField<scalar, GeoMesh> >& tdsf                     \
 454 )                                                                           \
 455 {                                                                           \
 456     const DimensionedField<scalar, GeoMesh>& dsf = tdsf();                  \
 457                                                                             \
 458     if (!dsf.dimensions().dimensionless())                                  \
 459     {                                                                       \
 460         FatalErrorIn                                                        \
 461         (                                                                   \
 462             #func"(const int n, "                                           \
 463             "const tmp<DimensionedField<scalar, GeoMesh> >& dsf)"           \
 464         )   << " : dsf not dimensionless"                                   \
 465             << abort(FatalError);                                           \
 466     }                                                                       \
 467                                                                             \
 468     tmp<DimensionedField<scalar, GeoMesh> > tFunc                           \
 469     (                                                                       \
 470         reuseTmpDimensionedField<scalar, scalar, GeoMesh>::New              \
 471         (                                                                   \
 472             tdsf,                                                           \
 473             #func "(" + name(n) + ',' + dsf.name() + ')',                   \
 474             dimless                                                         \
 475         )                                                                   \
 476     );                                                                      \
 477                                                                             \
 478     func(tFunc().field(), n, dsf.field());                                  \
 479                                                                             \
 480     reuseTmpDimensionedField<scalar, scalar, GeoMesh>::clear(tdsf);         \
 481                                                                             \
 482     return tFunc;                                                           \
 483 }
 484
 485 BesselFunc(jn)
 486 BesselFunc(yn)
 487
 488 #undef BesselFunc
 489
 490
 491 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 492
 493 } // End namespace Foam
 494
 495 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 496
 497 #include "undefFieldFunctionsM.H"
 498
 499 // ************************************************************************* //