src/foam/dimensionSet/dimensionSet.C

   1 /*---------------------------------------------------------------------------*\
   2   =========                 |
   3   \\      /  F ield         | foam-extend: Open Source CFD
   4    \\    /   O peration     | Version:     3.2
   5     \\  /    A nd           | Web:         http://www.foam-extend.org
   6      \\/     M anipulation  | For copyright notice see file Copyright
   7 -------------------------------------------------------------------------------
   8 License
   9     This file is part of foam-extend.
  10
  11     foam-extend 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 3 of the License, or (at your
  14     option) any later version.
  15
  16     foam-extend is distributed in the hope that it will be useful, but
  17     WITHOUT ANY WARRANTY; without even the implied warranty of
  18     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  19     General Public License for more details.
  20
  21     You should have received a copy of the GNU General Public License
  22     along with foam-extend.  If not, see <http://www.gnu.org/licenses/>.
  23
  24 \*---------------------------------------------------------------------------*/
  25
  26 #include "dimensionSet.H"
  27 #include "dimensionedScalar.H"
  28
  29 // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
  30
  31 defineTypeNameAndDebug(Foam::dimensionSet, 1);
  32 const Foam::scalar Foam::dimensionSet::smallExponent = SMALL;
  33
  34
  35 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
  36
  37 Foam::dimensionSet::dimensionSet
  38 (
  39     const scalar mass,
  40     const scalar length,
  41     const scalar time,
  42     const scalar temperature,
  43     const scalar moles,
  44     const scalar current,
  45     const scalar luminousIntensity
  46 )
  47 {
  48     exponents_[MASS] = mass;
  49     exponents_[LENGTH] = length;
  50     exponents_[TIME] = time;
  51     exponents_[TEMPERATURE] = temperature;
  52     exponents_[MOLES] = moles;
  53     exponents_[CURRENT] = current;
  54     exponents_[LUMINOUS_INTENSITY] = luminousIntensity;
  55 }
  56
  57
  58 Foam::dimensionSet::dimensionSet
  59 (
  60     const scalar mass,
  61     const scalar length,
  62     const scalar time,
  63     const scalar temperature,
  64     const scalar moles
  65 )
  66 {
  67     exponents_[MASS] = mass;
  68     exponents_[LENGTH] = length;
  69     exponents_[TIME] = time;
  70     exponents_[TEMPERATURE] = temperature;
  71     exponents_[MOLES] = moles;
  72     exponents_[CURRENT] = 0;
  73     exponents_[LUMINOUS_INTENSITY] = 0;
  74 }
  75
  76
  77 // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
  78
  79 bool Foam::dimensionSet::dimensionless() const
  80 {
  81     bool Dimensionless = true;
  82
  83     for (int Dimension=0; Dimension<nDimensions; Dimension++)
  84     {
  85         Dimensionless = Dimensionless &&
  86         (
  87             exponents_[Dimension] < smallExponent
  88          && exponents_[Dimension] > -smallExponent
  89         );
  90     }
  91
  92     return Dimensionless;
  93 }
  94
  95
  96 void Foam::dimensionSet::reset(const dimensionSet& ds)
  97 {
  98     for (int Dimension=0; Dimension<nDimensions; Dimension++)
  99     {
 100         exponents_[Dimension] = ds.exponents_[Dimension];
 101     }
 102 }
 103
 104
 105 // * * * * * * * * * * * * * * * Member Operators  * * * * * * * * * * * * * //
 106
 107 Foam::scalar Foam::dimensionSet::operator[](const dimensionType type) const
 108 {
 109     return exponents_[type];
 110 }
 111
 112 Foam::scalar& Foam::dimensionSet::operator[](const dimensionType type)
 113 {
 114     return exponents_[type];
 115 }
 116
 117
 118 bool Foam::dimensionSet::operator==(const dimensionSet& ds) const
 119 {
 120     bool equall = true;
 121
 122     for (int Dimension=0; Dimension<nDimensions; Dimension++)
 123     {
 124         equall = equall &&
 125             (mag(exponents_[Dimension] - ds.exponents_[Dimension])
 126           < smallExponent);
 127     }
 128
 129     return equall;
 130 }
 131
 132 bool Foam::dimensionSet::operator!=(const dimensionSet& ds) const
 133 {
 134     return !(operator==(ds));
 135 }
 136
 137
 138 bool Foam::dimensionSet::operator=(const dimensionSet& ds) const
 139 {
 140     if (dimensionSet::debug && *this != ds)
 141     {
 142         FatalErrorIn("dimensionSet::operator=(const dimensionSet& ds) const")
 143             << "Different dimensions for =" << endl
 144             << "     dimensions : " << *this << " = " << ds << endl
 145             << abort(FatalError);
 146     }
 147
 148     return true;
 149 }
 150
 151
 152 bool Foam::dimensionSet::operator+=(const dimensionSet& ds) const
 153 {
 154     if (dimensionSet::debug && *this != ds)
 155     {
 156         FatalErrorIn("dimensionSet::operator+=(const dimensionSet& ds) const")
 157             << "Different dimensions for +=" << endl
 158             << "     dimensions : " << *this << " = " << ds << endl
 159             << abort(FatalError);
 160     }
 161
 162     return true;
 163 }
 164
 165 bool Foam::dimensionSet::operator-=(const dimensionSet& ds) const
 166 {
 167     if (dimensionSet::debug && *this != ds)
 168     {
 169         FatalErrorIn("dimensionSet::operator-=(const dimensionSet& ds) const")
 170             << "Different dimensions for -=" << endl
 171             << "     dimensions : " << *this << " = " << ds << endl
 172             << abort(FatalError);
 173     }
 174
 175     return true;
 176 }
 177
 178 bool Foam::dimensionSet::operator*=(const dimensionSet& ds)
 179 {
 180     reset((*this)*ds);
 181
 182     return true;
 183 }
 184
 185 bool Foam::dimensionSet::operator/=(const dimensionSet& ds)
 186 {
 187     reset((*this)/ds);
 188
 189     return true;
 190 }
 191
 192
 193 // * * * * * * * * * * * * * * * Friend functions * * * * * * * * * * * * * * //
 194
 195 Foam::dimensionSet Foam::max(const dimensionSet& ds1, const dimensionSet& ds2)
 196 {
 197     if (dimensionSet::debug && ds1 != ds2)
 198     {
 199         FatalErrorIn("max(const dimensionSet& ds1, const dimensionSet& ds2)")
 200             << "Arguments of max have different dimensions" << endl
 201             << "     dimensions : " << ds1 << " and " << ds2 << endl
 202             << abort(FatalError);
 203     }
 204
 205     return ds1;
 206 }
 207
 208 Foam::dimensionSet Foam::min(const dimensionSet& ds1, const dimensionSet& ds2)
 209 {
 210     if (dimensionSet::debug && ds1 != ds2)
 211     {
 212         FatalErrorIn("min(const dimensionSet& ds1, const dimensionSet& ds2)")
 213             << "Arguments of min have different dimensions" << endl
 214             << "     dimensions : " << ds1 << " and " << ds2 << endl
 215             << abort(FatalError);
 216     }
 217
 218     return ds1;
 219 }
 220
 221
 222 Foam::dimensionSet Foam::cmptMultiply
 223 (
 224     const dimensionSet& ds1,
 225     const dimensionSet& ds2
 226 )
 227 {
 228     return ds1*ds2;
 229 }
 230
 231
 232 Foam::dimensionSet Foam::cmptDivide
 233 (
 234     const dimensionSet& ds1,
 235     const dimensionSet& ds2
 236 )
 237 {
 238     return ds1/ds2;
 239 }
 240
 241
 242 Foam::dimensionSet Foam::pow(const dimensionSet& ds, const scalar p)
 243 {
 244     dimensionSet dimPow
 245     (
 246         ds[dimensionSet::MASS]*p,
 247         ds[dimensionSet::LENGTH]*p,
 248         ds[dimensionSet::TIME]*p,
 249         ds[dimensionSet::TEMPERATURE]*p,
 250         ds[dimensionSet::MOLES]*p,
 251         ds[dimensionSet::CURRENT]*p,
 252         ds[dimensionSet::LUMINOUS_INTENSITY]*p
 253     );
 254
 255     return dimPow;
 256 }
 257
 258 Foam::dimensionSet Foam::pow
 259 (
 260     const dimensionSet& ds,
 261     const dimensionedScalar& dS
 262 )
 263 {
 264     if (dimensionSet::debug && !dS.dimensions().dimensionless())
 265     {
 266         FatalErrorIn("pow(const dimensionSet& ds, const dimensionedScalar& dS)")
 267             << "Exponent of pow are not dimensionless"
 268             << abort(FatalError);
 269     }
 270
 271     dimensionSet dimPow
 272     (
 273         ds[dimensionSet::MASS]*dS.value(),
 274         ds[dimensionSet::LENGTH]*dS.value(),
 275         ds[dimensionSet::TIME]*dS.value(),
 276         ds[dimensionSet::TEMPERATURE]*dS.value(),
 277         ds[dimensionSet::MOLES]*dS.value(),
 278         ds[dimensionSet::CURRENT]*dS.value(),
 279         ds[dimensionSet::LUMINOUS_INTENSITY]*dS.value()
 280     );
 281
 282     return dimPow;
 283 }
 284
 285 Foam::dimensionSet Foam::pow
 286 (
 287     const dimensionedScalar& dS,
 288     const dimensionSet& ds
 289 )
 290 {
 291     if
 292     (
 293         dimensionSet::debug
 294      && !dS.dimensions().dimensionless()
 295      && !ds.dimensionless())
 296     {
 297         FatalErrorIn("pow(const dimensionedScalar& dS, const dimensionSet& ds)")
 298             << "Argument or exponent of pow not dimensionless" << endl
 299             << abort(FatalError);
 300     }
 301
 302     return ds;
 303 }
 304
 305
 306 Foam::dimensionSet Foam::sqr(const dimensionSet& ds)
 307 {
 308     return pow(ds, 2);
 309 }
 310
 311 Foam::dimensionSet Foam::pow3(const dimensionSet& ds)
 312 {
 313     return pow(ds, 3);
 314 }
 315
 316 Foam::dimensionSet Foam::pow4(const dimensionSet& ds)
 317 {
 318     return pow(ds, 4);
 319 }
 320
 321 Foam::dimensionSet Foam::pow5(const dimensionSet& ds)
 322 {
 323     return pow(ds, 5);
 324 }
 325
 326 Foam::dimensionSet Foam::pow6(const dimensionSet& ds)
 327 {
 328     return pow(ds, 6);
 329 }
 330
 331 Foam::dimensionSet Foam::sqrt(const dimensionSet& ds)
 332 {
 333     return pow(ds, 0.5);
 334 }
 335
 336 Foam::dimensionSet Foam::magSqr(const dimensionSet& ds)
 337 {
 338     return pow(ds, 2);
 339 }
 340
 341 Foam::dimensionSet Foam::mag(const dimensionSet& ds)
 342 {
 343     return ds;
 344 }
 345
 346 Foam::dimensionSet Foam::sign(const dimensionSet&)
 347 {
 348     return dimless;
 349 }
 350
 351 Foam::dimensionSet Foam::pos(const dimensionSet&)
 352 {
 353     return dimless;
 354 }
 355
 356 Foam::dimensionSet Foam::neg(const dimensionSet&)
 357 {
 358     return dimless;
 359 }
 360
 361 Foam::dimensionSet Foam::inv(const dimensionSet& ds)
 362 {
 363     return dimless/ds;
 364 }
 365
 366 Foam::dimensionSet Foam::hinv(const dimensionSet& ds)
 367 {
 368     return inv(ds);
 369 }
 370
 371 Foam::dimensionSet Foam::trans(const dimensionSet& ds)
 372 {
 373     if (dimensionSet::debug && !ds.dimensionless())
 374     {
 375         FatalErrorIn("trans(const dimensionSet& ds)")
 376             << "Argument of trancendental function not dimensionless"
 377             << abort(FatalError);
 378     }
 379
 380     return ds;
 381 }
 382
 383 Foam::dimensionSet Foam::transform(const dimensionSet& ds)
 384 {
 385     return ds;
 386 }
 387
 388
 389 // * * * * * * * * * * * * * * * Friend Operators  * * * * * * * * * * * * * //
 390
 391 Foam::dimensionSet Foam::operator-(const dimensionSet& ds)
 392 {
 393     return ds;
 394 }
 395
 396 Foam::dimensionSet Foam::operator+
 397 (
 398     const dimensionSet& ds1,
 399     const dimensionSet& ds2
 400 )
 401 {
 402     dimensionSet dimSum(ds1);
 403
 404     if (dimensionSet::debug && ds1 != ds2)
 405     {
 406         FatalErrorIn
 407             ("operator+(const dimensionSet& ds1, const dimensionSet& ds2)")
 408             << "LHS and RHS of + have different dimensions" << endl
 409             << "     dimensions : " << ds1 << " + " << ds2 << endl
 410             << abort(FatalError);
 411     }
 412
 413     return dimSum;
 414 }
 415
 416 Foam::dimensionSet Foam::operator-
 417 (
 418     const dimensionSet& ds1,
 419     const dimensionSet& ds2
 420 )
 421 {
 422     dimensionSet dimDifference(ds1);
 423
 424     if (dimensionSet::debug && ds1 != ds2)
 425     {
 426         FatalErrorIn
 427             ("operator-(const dimensionSet& ds1, const dimensionSet& ds2)")
 428             << "LHS and RHS of - have different dimensions" << endl
 429             << "     dimensions : " << ds1 << " - " << ds2 << endl
 430             << abort(FatalError);
 431     }
 432
 433     return dimDifference;
 434 }
 435
 436 Foam::dimensionSet Foam::operator*
 437 (
 438     const dimensionSet& ds1,
 439     const dimensionSet& ds2
 440 )
 441 {
 442     dimensionSet dimProduct(ds1);
 443
 444     for (int Dimension=0; Dimension<dimensionSet::nDimensions; Dimension++)
 445     {
 446         dimProduct.exponents_[Dimension] += ds2.exponents_[Dimension];
 447     }
 448
 449     return dimProduct;
 450 }
 451
 452 Foam::dimensionSet Foam::operator/
 453 (
 454     const dimensionSet& ds1,
 455     const dimensionSet& ds2
 456 )
 457 {
 458     dimensionSet dimQuotient(ds1);
 459
 460     for (int Dimension=0; Dimension<dimensionSet::nDimensions; Dimension++)
 461     {
 462         dimQuotient.exponents_[Dimension] -= ds2.exponents_[Dimension];
 463     }
 464
 465     return dimQuotient;
 466 }
 467
 468
 469 Foam::dimensionSet Foam::operator&
 470 (
 471     const dimensionSet& ds1,
 472     const dimensionSet& ds2
 473 )
 474 {
 475     return ds1*ds2;
 476 }
 477
 478 Foam::dimensionSet Foam::operator^
 479 (
 480     const dimensionSet& ds1,
 481     const dimensionSet& ds2
 482 )
 483 {
 484     return ds1*ds2;
 485 }
 486
 487 Foam::dimensionSet Foam::operator&&
 488 (
 489     const dimensionSet& ds1,
 490     const dimensionSet& ds2
 491 )
 492 {
 493     return ds1*ds2;
 494 }
 495
 496
 497 // ************************************************************************* //