src/OpenFOAM/dimensionedTypes/dimensionedType/dimensionedType.C

   1 /*---------------------------------------------------------------------------*\
   2   =========                 |
   3   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
   4    \\    /   O peration     |
   5     \\  /    A nd           | Copyright (C) 1991-2009 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 the
  13     Free Software Foundation; either version 2 of the License, or (at your
  14     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, write to the Free Software Foundation,
  23     Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
  24
  25 \*---------------------------------------------------------------------------*/
  26
  27 #include "dimensionedType.H"
  28 #include "pTraits.H"
  29 #include "dictionary.H"
  30
  31 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
  32
  33 namespace Foam
  34 {
  35
  36 // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
  37
  38 template <class Type>
  39 dimensioned<Type> dimensioned<Type>::lookupOrDefault
  40 (
  41     const word& name,
  42     const dictionary& dict,
  43     const Type& defaultValue,
  44     const dimensionSet& dims
  45 )
  46 {
  47     Type value = dict.lookupOrDefault<Type>(name, defaultValue);
  48     return dimensioned<Type>(name, dims, value);
  49 }
  50
  51
  52 template <class Type>
  53 dimensioned<Type> dimensioned<Type>::lookupOrAddToDict
  54 (
  55     const word& name,
  56     dictionary& dict,
  57     const Type& defaultValue,
  58     const dimensionSet& dims
  59 )
  60 {
  61     Type value = dict.lookupOrAddDefault<Type>(name, defaultValue);
  62     return dimensioned<Type>(name, dims, value);
  63 }
  64
  65
  66 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
  67
  68 template <class Type>
  69 dimensioned<Type>::dimensioned
  70 (
  71     const word& name,
  72     const dimensionSet& dimSet,
  73     const Type t
  74 )
  75 :
  76     name_(name),
  77     dimensions_(dimSet),
  78     value_(t)
  79 {}
  80
  81
  82 template <class Type>
  83 dimensioned<Type>::dimensioned
  84 (
  85     const word& name,
  86     const dimensioned<Type>& dt
  87 )
  88 :
  89     name_(name),
  90     dimensions_(dt.dimensions_),
  91     value_(dt.value_)
  92 {}
  93
  94
  95 template <class Type>
  96 dimensioned<Type>::dimensioned
  97 (
  98     Istream& is
  99 )
 100 :
 101     name_(is),
 102     dimensions_(is),
 103     value_(pTraits<Type>(is))
 104 {}
 105
 106
 107 template <class Type>
 108 dimensioned<Type>::dimensioned
 109 (
 110     const word& name,
 111     Istream& is
 112 )
 113 :
 114     name_(name),
 115     dimensions_(is),
 116     value_(pTraits<Type>(is))
 117 {}
 118
 119
 120 template <class Type>
 121 dimensioned<Type>::dimensioned
 122 (
 123     const word& name,
 124     const dimensionSet& dimSet,
 125     Istream& is
 126 )
 127 :
 128     name_(name),
 129     dimensions_(dimSet),
 130     value_(pTraits<Type>(is))
 131 {}
 132
 133
 134 // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
 135
 136 template <class Type>
 137 const word& dimensioned<Type>::name() const
 138 {
 139     return name_;
 140 }
 141
 142 template <class Type>
 143 word& dimensioned<Type>::name()
 144 {
 145     return name_;
 146 }
 147
 148
 149 template <class Type>
 150 const dimensionSet& dimensioned<Type>::dimensions() const
 151 {
 152     return dimensions_;
 153 }
 154
 155 template <class Type>
 156 dimensionSet& dimensioned<Type>::dimensions()
 157 {
 158     return dimensions_;
 159 }
 160
 161
 162 template <class Type>
 163 const Type& dimensioned<Type>::value() const
 164 {
 165     return value_;
 166 }
 167
 168 template <class Type>
 169 Type& dimensioned<Type>::value()
 170 {
 171     return value_;
 172 }
 173
 174
 175 template <class Type>
 176 dimensioned<typename dimensioned<Type>::cmptType> dimensioned<Type>::component
 177 (
 178     const direction d
 179 ) const
 180 {
 181     return dimensioned<cmptType>
 182     (
 183         name_ + ".component(" + Foam::name(d) + ')',
 184         dimensions_,
 185         value_.component(d)
 186     );
 187 }
 188
 189
 190 template <class Type>
 191 void dimensioned<Type>::replace
 192 (
 193     const direction d,
 194     const dimensioned<typename dimensioned<Type>::cmptType>& dc
 195 )
 196 {
 197     dimensions_ = dc.dimensions();
 198     value_.replace(d, dc.value());
 199 }
 200
 201
 202 template <class Type>
 203 bool dimensioned<Type>::readIfPresent(const dictionary& dict)
 204 {
 205     return dict.readIfPresent(name_, value_);
 206 }
 207
 208
 209 // * * * * * * * * * * * * * * * Member Operators  * * * * * * * * * * * * * //
 210
 211 template <class Type>
 212 dimensioned<typename dimensioned<Type>::cmptType> dimensioned<Type>::operator[]
 213 (
 214     const direction d
 215 ) const
 216 {
 217     return component(d);
 218 }
 219
 220
 221 template <class Type>
 222 void dimensioned<Type>::operator+=
 223 (
 224     const dimensioned<Type>& dt
 225 )
 226 {
 227     dimensions_ += dt.dimensions_;
 228     value_ += dt.value_;
 229 }
 230
 231
 232 template <class Type>
 233 void dimensioned<Type>::operator-=
 234 (
 235     const dimensioned<Type>& dt
 236 )
 237 {
 238     dimensions_ -= dt.dimensions_;
 239     value_ -= dt.value_;
 240 }
 241
 242
 243 template <class Type>
 244 void dimensioned<Type>::operator*=
 245 (
 246     const scalar s
 247 )
 248 {
 249     value_ *= s;
 250 }
 251
 252
 253 template <class Type>
 254 void dimensioned<Type>::operator/=
 255 (
 256     const scalar s
 257 )
 258 {
 259     value_ /= s;
 260 }
 261
 262
 263 // * * * * * * * * * * * * * * * Friend Functions  * * * * * * * * * * * * * //
 264
 265 template<class Type, int r>
 266 dimensioned<typename powProduct<Type, r>::type>
 267 pow(const dimensioned<Type>& dt, typename powProduct<Type, r>::type)
 268 {
 269     return dimensioned<typename powProduct<Type, r>::type>
 270     (
 271         "pow(" + dt.name() + ',' + name(r) + ')',
 272         pow(dt.dimensions(), r),
 273         pow(dt.value(), 2)
 274     );
 275 }
 276
 277 template<class Type>
 278 dimensioned<typename outerProduct<Type, Type>::type>
 279 sqr(const dimensioned<Type>& dt)
 280 {
 281     return dimensioned<typename outerProduct<Type, Type>::type>
 282     (
 283         "sqr(" + dt.name() + ')',
 284         sqr(dt.dimensions()),
 285         sqr(dt.value())
 286     );
 287 }
 288
 289 template<class Type>
 290 dimensioned<scalar> magSqr(const dimensioned<Type>& dt)
 291 {
 292     return dimensioned<scalar>
 293     (
 294         "magSqr(" + dt.name() + ')',
 295         magSqr(dt.dimensions()),
 296         magSqr(dt.value())
 297     );
 298 }
 299
 300 template<class Type>
 301 dimensioned<scalar> mag(const dimensioned<Type>& dt)
 302 {
 303     return dimensioned<scalar>
 304     (
 305         "mag(" + dt.name() + ')',
 306         dt.dimensions(),
 307         mag(dt.value())
 308     );
 309 }
 310
 311
 312 template <class Type>
 313 dimensioned<Type> max
 314 (
 315     const dimensioned<Type>& dt1,
 316     const dimensioned<Type>& dt2
 317 )
 318 {
 319     if (dt1.dimensions() != dt2.dimensions())
 320     {
 321         FatalErrorIn("max(const dimensioned<Type>&, const dimensioned<Type>&)")
 322             << "dimensions of arguments are not equal"
 323             << abort(FatalError);
 324     }
 325
 326     return dimensioned<Type>
 327     (
 328         "max(" + dt1.name() + ',' + dt2.name() + ')',
 329         dt1.dimensions(),
 330         max(dt1.value(), dt2.value())
 331     );
 332 }
 333
 334
 335 template <class Type>
 336 dimensioned<Type> min
 337 (
 338     const dimensioned<Type>& dt1,
 339     const dimensioned<Type>& dt2
 340 )
 341 {
 342     if (dt1.dimensions() != dt2.dimensions())
 343     {
 344         FatalErrorIn("min(const dimensioned<Type>&, const dimensioned<Type>&)")
 345             << "dimensions of arguments are not equal"
 346             << abort(FatalError);
 347     }
 348
 349     return dimensioned<Type>
 350     (
 351         "min(" + dt1.name() + ',' + dt2.name() + ')',
 352         dt1.dimensions(),
 353         min(dt1.value(), dt2.value())
 354     );
 355 }
 356
 357
 358 // * * * * * * * * * * * * * * * IOstream Operators  * * * * * * * * * * * * //
 359
 360 template <class Type>
 361 Istream& operator>>(Istream& is, dimensioned<Type>& dt)
 362 {
 363     // do a stream read op for a Type and a dimensions()et
 364     is >> dt.name_ >> dt.dimensions_ >> dt.value_;
 365
 366     // Check state of Istream
 367     is.check("Istream& operator>>(Istream&, dimensioned<Type>&)");
 368
 369     return is;
 370 }
 371
 372
 373 template <class Type>
 374 Ostream& operator<<(Ostream& os, const dimensioned<Type>& dt)
 375 {
 376     // do a stream write op for a dimensions()et
 377     os  << dt.name() << token::SPACE
 378         << dt.dimensions() << token::SPACE
 379         << dt.value();
 380
 381     // Check state of Ostream
 382     os.check("Ostream& operator<<(Ostream&, const dimensioned<Type>&)");
 383
 384     return os;
 385 }
 386
 387
 388 // * * * * * * * * * * * * * * * Global Operators  * * * * * * * * * * * * * //
 389
 390 template <class Type>
 391 bool operator>
 392 (
 393     const dimensioned<Type>& dt1,
 394     const dimensioned<Type>& dt2
 395 )
 396 {
 397     return dt1.value() > dt2.value();
 398 }
 399
 400
 401 template <class Type>
 402 bool operator<
 403 (
 404     const dimensioned<Type>& dt1,
 405     const dimensioned<Type>& dt2
 406 )
 407 {
 408     return dt1.value() < dt2.value();
 409 }
 410
 411
 412 template <class Type>
 413 dimensioned<Type> operator+
 414 (
 415     const dimensioned<Type>& dt1,
 416     const dimensioned<Type>& dt2
 417 )
 418 {
 419     return dimensioned<Type>
 420     (
 421         '(' + dt1.name() + '+' + dt2.name() + ')',
 422         dt1.dimensions() + dt2.dimensions(),
 423         dt1.value() + dt2.value()
 424     );
 425 }
 426
 427
 428 template <class Type>
 429 dimensioned<Type> operator-(const dimensioned<Type>& dt)
 430 {
 431     return dimensioned<Type>
 432     (
 433         '-' + dt.name(),
 434         dt.dimensions(),
 435         -dt.value()
 436     );
 437 }
 438
 439
 440 template <class Type>
 441 dimensioned<Type> operator-
 442 (
 443     const dimensioned<Type>& dt1,
 444     const dimensioned<Type>& dt2
 445 )
 446 {
 447     return dimensioned<Type>
 448     (
 449         '(' + dt1.name() + '-' + dt2.name() + ')',
 450         dt1.dimensions() - dt2.dimensions(),
 451         dt1.value() - dt2.value()
 452     );
 453 }
 454
 455
 456 template <class Type>
 457 dimensioned<Type> operator*
 458 (
 459     const dimensioned<scalar>& ds,
 460     const dimensioned<Type>& dt
 461 )
 462 {
 463     return dimensioned<Type>
 464     (
 465         '(' + ds.name() + '*' + dt.name() + ')',
 466         ds.dimensions() * dt.dimensions(),
 467         ds.value() * dt.value()
 468     );
 469 }
 470
 471
 472 template <class Type>
 473 dimensioned<Type> operator/
 474 (
 475     const dimensioned<Type>& dt,
 476     const dimensioned<scalar>& ds
 477 )
 478 {
 479     return dimensioned<Type>
 480     (
 481         '(' + dt.name() + '|' + ds.name() + ')',
 482         dt.dimensions()/ds.dimensions(),
 483         dt.value()/ds.value()
 484     );
 485 }
 486
 487
 488 // Products
 489 // ~~~~~~~~
 490
 491 #define PRODUCT_OPERATOR(product, op, opFunc)                                 \
 492                                                                               \
 493 template<class Type1, class Type2>                                            \
 494 dimensioned<typename product<Type1, Type2>::type>                             \
 495 operator op(const dimensioned<Type1>& dt1, const dimensioned<Type2>& dt2)     \
 496 {                                                                             \
 497     return dimensioned<typename product<Type1, Type2>::type>                  \
 498     (                                                                         \
 499         '(' + dt1.name() + #op + dt2.name() + ')',                            \
 500         dt1.dimensions() op dt2.dimensions(),                                 \
 501         dt1.value() op dt2.value()                                            \
 502     );                                                                        \
 503 }                                                                             \
 504                                                                               \
 505 template<class Type, class Form, class Cmpt, int nCmpt>                       \
 506 dimensioned<typename product<Type, Form>::type>                               \
 507 operator op                                                                   \
 508 (                                                                             \
 509     const dimensioned<Type>& dt1,                                             \
 510     const VectorSpace<Form,Cmpt,nCmpt>& t2                                    \
 511 )                                                                             \
 512 {                                                                             \
 513     return dimensioned<typename product<Type, Form>::type>                    \
 514     (                                                                         \
 515         '(' + dt1.name() + #op + name(t2) + ')',                              \
 516         dt1.dimensions(),                                                     \
 517         dt1.value() op static_cast<const Form&>(t2)                           \
 518     );                                                                        \
 519 }                                                                             \
 520                                                                               \
 521 template<class Type, class Form, class Cmpt, int nCmpt>                       \
 522 dimensioned<typename product<Form, Type>::type>                               \
 523 operator op                                                                   \
 524 (                                                                             \
 525     const VectorSpace<Form,Cmpt,nCmpt>& t1,                                   \
 526     const dimensioned<Type>& dt2                                              \
 527 )                                                                             \
 528 {                                                                             \
 529     return dimensioned<typename product<Form, Type>::type>                    \
 530     (                                                                         \
 531         '(' + name(t1) + #op + dt2.name() + ')',                              \
 532         dt2.dimensions(),                                                     \
 533         static_cast<const Form&>(t1) op dt2.value()                           \
 534     );                                                                        \
 535 }
 536
 537
 538 PRODUCT_OPERATOR(outerProduct, *, outer)
 539 PRODUCT_OPERATOR(crossProduct, ^, cross)
 540 PRODUCT_OPERATOR(innerProduct, &, dot)
 541 PRODUCT_OPERATOR(scalarProduct, &&, dotdot)
 542
 543 #undef PRODUCT_OPERATOR
 544
 545
 546 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 547
 548 } // End namespace Foam
 549
 550 // ************************************************************************* //