src/OpenFOAM/dimensionSet/dimensionSet.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 "dimensionSet.H"
  27 #include "dimensionedScalar.H"
  28 #include "OStringStream.H"
  29
  30 // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
  31
  32 defineTypeNameAndDebug(Foam::dimensionSet, 1);
  33 const Foam::scalar Foam::dimensionSet::smallExponent = SMALL;
  34
  35
  36 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
  37
  38 Foam::dimensionSet::dimensionSet
  39 (
  40     const scalar mass,
  41     const scalar length,
  42     const scalar time,
  43     const scalar temperature,
  44     const scalar moles,
  45     const scalar current,
  46     const scalar luminousIntensity
  47 )
  48 {
  49     exponents_[MASS] = mass;
  50     exponents_[LENGTH] = length;
  51     exponents_[TIME] = time;
  52     exponents_[TEMPERATURE] = temperature;
  53     exponents_[MOLES] = moles;
  54     exponents_[CURRENT] = current;
  55     exponents_[LUMINOUS_INTENSITY] = luminousIntensity;
  56 }
  57
  58
  59 Foam::dimensionSet::dimensionSet
  60 (
  61     const scalar mass,
  62     const scalar length,
  63     const scalar time,
  64     const scalar temperature,
  65     const scalar moles
  66 )
  67 {
  68     exponents_[MASS] = mass;
  69     exponents_[LENGTH] = length;
  70     exponents_[TIME] = time;
  71     exponents_[TEMPERATURE] = temperature;
  72     exponents_[MOLES] = moles;
  73     exponents_[CURRENT] = 0;
  74     exponents_[LUMINOUS_INTENSITY] = 0;
  75 }
  76
  77
  78 // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
  79
  80 bool Foam::dimensionSet::dimensionless() const
  81 {
  82     for (int Dimension=0; Dimension<nDimensions; ++Dimension)
  83     {
  84         // ie, mag(exponents_[Dimension]) > smallExponent
  85         if
  86         (
  87             exponents_[Dimension] > smallExponent
  88          || exponents_[Dimension] < -smallExponent
  89         )
  90         {
  91             return false;
  92         }
  93     }
  94
  95     return true;
  96 }
  97
  98
  99 void Foam::dimensionSet::reset(const dimensionSet& ds)
 100 {
 101     for (int Dimension=0; Dimension<nDimensions; ++Dimension)
 102     {
 103         exponents_[Dimension] = ds.exponents_[Dimension];
 104     }
 105 }
 106
 107
 108 Foam::string Foam::dimensionSet::asText() const
 109 {
 110     OStringStream buf;
 111
 112     bool Dimensionless = true;
 113
 114     for (int Dimension=0; Dimension < dimensionSet::nDimensions-1; ++Dimension)
 115     {
 116         const scalar& expt = exponents_[Dimension];
 117
 118         if (expt < smallExponent && expt > -smallExponent)
 119         {
 120             continue;
 121         }
 122
 123         if (Dimensionless)
 124         {
 125             Dimensionless = false;
 126         }
 127         else
 128         {
 129             buf << ' ';
 130         }
 131
 132         // note: currently only handle SI
 133         switch (Dimension)
 134         {
 135             case MASS:
 136                 buf << "kg";
 137                 break;
 138
 139             case LENGTH:
 140                 buf << "m";
 141                 break;
 142
 143             case TIME:
 144                 buf << "s";
 145                 break;
 146
 147             case TEMPERATURE:
 148                 buf << "K";
 149                 break;
 150
 151             case MOLES:
 152                 buf << "mol";
 153                 break;
 154
 155             case CURRENT:
 156                 buf << "A";
 157                 break;
 158
 159             case LUMINOUS_INTENSITY:
 160                 buf << "Cd";
 161                 break;
 162
 163             default:
 164                 buf << "??";  // this shouldn't be - flag as being weird
 165                 break;
 166         }
 167
 168         if (expt != 1)
 169         {
 170             buf << '^' << expt;
 171         }
 172     }
 173
 174     if (Dimensionless)
 175     {
 176         return "none";
 177     }
 178     else
 179     {
 180         return buf.str();
 181     }
 182 }
 183
 184
 185 // * * * * * * * * * * * * * * * Member Operators  * * * * * * * * * * * * * //
 186
 187 Foam::scalar Foam::dimensionSet::operator[](const dimensionType type) const
 188 {
 189     return exponents_[type];
 190 }
 191
 192
 193 Foam::scalar& Foam::dimensionSet::operator[](const dimensionType type)
 194 {
 195     return exponents_[type];
 196 }
 197
 198
 199 bool Foam::dimensionSet::operator==(const dimensionSet& ds) const
 200 {
 201     for (int Dimension=0; Dimension < nDimensions; ++Dimension)
 202     {
 203         if
 204         (
 205             mag(exponents_[Dimension] - ds.exponents_[Dimension])
 206           > smallExponent
 207         )
 208         {
 209             return false;
 210         }
 211     }
 212
 213     return true;
 214 }
 215
 216
 217 bool Foam::dimensionSet::operator!=(const dimensionSet& ds) const
 218 {
 219     return !(operator==(ds));
 220 }
 221
 222
 223 bool Foam::dimensionSet::operator=(const dimensionSet& ds) const
 224 {
 225     if (dimensionSet::debug && *this != ds)
 226     {
 227         FatalErrorIn("dimensionSet::operator=(const dimensionSet&) const")
 228             << "Different dimensions for =" << endl
 229             << "     dimensions : " << *this << " = " << ds << endl
 230             << abort(FatalError);
 231     }
 232
 233     return true;
 234 }
 235
 236
 237 bool Foam::dimensionSet::operator+=(const dimensionSet& ds) const
 238 {
 239     if (dimensionSet::debug && *this != ds)
 240     {
 241         FatalErrorIn("dimensionSet::operator+=(const dimensionSet&) const")
 242             << "Different dimensions for +=" << endl
 243             << "     dimensions : " << *this << " = " << ds << endl
 244             << abort(FatalError);
 245     }
 246
 247     return true;
 248 }
 249
 250
 251 bool Foam::dimensionSet::operator-=(const dimensionSet& ds) const
 252 {
 253     if (dimensionSet::debug && *this != ds)
 254     {
 255         FatalErrorIn("dimensionSet::operator-=(const dimensionSet&) const")
 256             << "Different dimensions for -=" << endl
 257             << "     dimensions : " << *this << " = " << ds << endl
 258             << abort(FatalError);
 259     }
 260
 261     return true;
 262 }
 263
 264
 265 bool Foam::dimensionSet::operator*=(const dimensionSet& ds)
 266 {
 267     reset((*this)*ds);
 268
 269     return true;
 270 }
 271
 272
 273 bool Foam::dimensionSet::operator/=(const dimensionSet& ds)
 274 {
 275     reset((*this)/ds);
 276
 277     return true;
 278 }
 279
 280
 281 // * * * * * * * * * * * * * * * Friend functions * * * * * * * * * * * * * * //
 282
 283 Foam::dimensionSet Foam::max(const dimensionSet& ds1, const dimensionSet& ds2)
 284 {
 285     if (dimensionSet::debug && ds1 != ds2)
 286     {
 287         FatalErrorIn("max(const dimensionSet&, const dimensionSet&)")
 288             << "Arguments of max have different dimensions" << endl
 289             << "     dimensions : " << ds1 << " and " << ds2 << endl
 290             << abort(FatalError);
 291     }
 292
 293     return ds1;
 294 }
 295
 296
 297 Foam::dimensionSet Foam::min(const dimensionSet& ds1, const dimensionSet& ds2)
 298 {
 299     if (dimensionSet::debug && ds1 != ds2)
 300     {
 301         FatalErrorIn("min(const dimensionSet&, const dimensionSet&)")
 302             << "Arguments of min have different dimensions" << endl
 303             << "     dimensions : " << ds1 << " and " << ds2 << endl
 304             << abort(FatalError);
 305     }
 306
 307     return ds1;
 308 }
 309
 310
 311 Foam::dimensionSet Foam::cmptMultiply
 312 (
 313     const dimensionSet& ds1,
 314     const dimensionSet& ds2
 315 )
 316 {
 317     return ds1*ds2;
 318 }
 319
 320
 321 Foam::dimensionSet Foam::cmptDivide
 322 (
 323     const dimensionSet& ds1,
 324     const dimensionSet& ds2
 325 )
 326 {
 327     return ds1/ds2;
 328 }
 329
 330
 331 Foam::dimensionSet Foam::pow(const dimensionSet& ds, const scalar p)
 332 {
 333     dimensionSet dimPow
 334     (
 335         ds[dimensionSet::MASS]*p,
 336         ds[dimensionSet::LENGTH]*p,
 337         ds[dimensionSet::TIME]*p,
 338         ds[dimensionSet::TEMPERATURE]*p,
 339         ds[dimensionSet::MOLES]*p,
 340         ds[dimensionSet::CURRENT]*p,
 341         ds[dimensionSet::LUMINOUS_INTENSITY]*p
 342     );
 343
 344     return dimPow;
 345 }
 346
 347
 348 Foam::dimensionSet Foam::pow
 349 (
 350     const dimensionSet& ds,
 351     const dimensionedScalar& dS
 352 )
 353 {
 354     if (dimensionSet::debug && !dS.dimensions().dimensionless())
 355     {
 356         FatalErrorIn("pow(const dimensionSet&, const dimensionedScalar&)")
 357             << "Exponent of pow is not dimensionless"
 358             << abort(FatalError);
 359     }
 360
 361     dimensionSet dimPow
 362     (
 363         ds[dimensionSet::MASS]*dS.value(),
 364         ds[dimensionSet::LENGTH]*dS.value(),
 365         ds[dimensionSet::TIME]*dS.value(),
 366         ds[dimensionSet::TEMPERATURE]*dS.value(),
 367         ds[dimensionSet::MOLES]*dS.value(),
 368         ds[dimensionSet::CURRENT]*dS.value(),
 369         ds[dimensionSet::LUMINOUS_INTENSITY]*dS.value()
 370     );
 371
 372     return dimPow;
 373 }
 374
 375
 376 Foam::dimensionSet Foam::pow
 377 (
 378     const dimensionedScalar& dS,
 379     const dimensionSet& ds
 380 )
 381 {
 382     if
 383     (
 384         dimensionSet::debug
 385      && !dS.dimensions().dimensionless()
 386      && !ds.dimensionless()
 387     )
 388     {
 389         FatalErrorIn("pow(const dimensionedScalar&, const dimensionSet&)")
 390             << "Argument or exponent of pow not dimensionless" << endl
 391             << abort(FatalError);
 392     }
 393
 394     return ds;
 395 }
 396
 397
 398 Foam::dimensionSet Foam::sqr(const dimensionSet& ds)
 399 {
 400     return pow(ds, 2);
 401 }
 402
 403
 404 Foam::dimensionSet Foam::pow3(const dimensionSet& ds)
 405 {
 406     return pow(ds, 3);
 407 }
 408
 409
 410 Foam::dimensionSet Foam::pow4(const dimensionSet& ds)
 411 {
 412     return pow(ds, 4);
 413 }
 414
 415
 416 Foam::dimensionSet Foam::pow5(const dimensionSet& ds)
 417 {
 418     return pow(ds, 5);
 419 }
 420
 421
 422 Foam::dimensionSet Foam::pow6(const dimensionSet& ds)
 423 {
 424     return pow(ds, 6);
 425 }
 426
 427
 428 Foam::dimensionSet Foam::pow025(const dimensionSet& ds)
 429 {
 430     return sqrt(sqrt(ds));
 431 }
 432
 433
 434 Foam::dimensionSet Foam::sqrt(const dimensionSet& ds)
 435 {
 436     return pow(ds, 0.5);
 437 }
 438
 439
 440 Foam::dimensionSet Foam::magSqr(const dimensionSet& ds)
 441 {
 442     return pow(ds, 2);
 443 }
 444
 445
 446 Foam::dimensionSet Foam::mag(const dimensionSet& ds)
 447 {
 448     return ds;
 449 }
 450
 451
 452 Foam::dimensionSet Foam::sign(const dimensionSet&)
 453 {
 454     return dimless;
 455 }
 456
 457
 458 Foam::dimensionSet Foam::pos(const dimensionSet&)
 459 {
 460     return dimless;
 461 }
 462
 463
 464 Foam::dimensionSet Foam::neg(const dimensionSet&)
 465 {
 466     return dimless;
 467 }
 468
 469
 470 Foam::dimensionSet Foam::inv(const dimensionSet& ds)
 471 {
 472     return dimless/ds;
 473 }
 474
 475
 476 Foam::dimensionSet Foam::trans(const dimensionSet& ds)
 477 {
 478     if (dimensionSet::debug && !ds.dimensionless())
 479     {
 480         FatalErrorIn("trans(const dimensionSet&)")
 481             << "Argument of trancendental function not dimensionless"
 482             << abort(FatalError);
 483     }
 484
 485     return ds;
 486 }
 487
 488
 489 Foam::dimensionSet Foam::transform(const dimensionSet& ds)
 490 {
 491     return ds;
 492 }
 493
 494
 495 // * * * * * * * * * * * * * * * Friend Operators  * * * * * * * * * * * * * //
 496
 497 Foam::dimensionSet Foam::operator-(const dimensionSet& ds)
 498 {
 499     return ds;
 500 }
 501
 502
 503 Foam::dimensionSet Foam::operator+
 504 (
 505     const dimensionSet& ds1,
 506     const dimensionSet& ds2
 507 )
 508 {
 509     dimensionSet dimSum(ds1);
 510
 511     if (dimensionSet::debug && ds1 != ds2)
 512     {
 513         FatalErrorIn
 514             ("operator+(const dimensionSet&, const dimensionSet&)")
 515             << "LHS and RHS of + have different dimensions" << endl
 516             << "     dimensions : " << ds1 << " + " << ds2 << endl
 517             << abort(FatalError);
 518     }
 519
 520     return dimSum;
 521 }
 522
 523
 524 Foam::dimensionSet Foam::operator-
 525 (
 526     const dimensionSet& ds1,
 527     const dimensionSet& ds2
 528 )
 529 {
 530     dimensionSet dimDifference(ds1);
 531
 532     if (dimensionSet::debug && ds1 != ds2)
 533     {
 534         FatalErrorIn
 535             ("operator-(const dimensionSet&, const dimensionSet&)")
 536             << "LHS and RHS of - have different dimensions" << endl
 537             << "     dimensions : " << ds1 << " - " << ds2 << endl
 538             << abort(FatalError);
 539     }
 540
 541     return dimDifference;
 542 }
 543
 544
 545 Foam::dimensionSet Foam::operator*
 546 (
 547     const dimensionSet& ds1,
 548     const dimensionSet& ds2
 549 )
 550 {
 551     dimensionSet dimProduct(ds1);
 552
 553     for (int Dimension=0; Dimension<dimensionSet::nDimensions; Dimension++)
 554     {
 555         dimProduct.exponents_[Dimension] += ds2.exponents_[Dimension];
 556     }
 557
 558     return dimProduct;
 559 }
 560
 561
 562 Foam::dimensionSet Foam::operator/
 563 (
 564     const dimensionSet& ds1,
 565     const dimensionSet& ds2
 566 )
 567 {
 568     dimensionSet dimQuotient(ds1);
 569
 570     for (int Dimension=0; Dimension<dimensionSet::nDimensions; Dimension++)
 571     {
 572         dimQuotient.exponents_[Dimension] -= ds2.exponents_[Dimension];
 573     }
 574
 575     return dimQuotient;
 576 }
 577
 578
 579 Foam::dimensionSet Foam::operator&
 580 (
 581     const dimensionSet& ds1,
 582     const dimensionSet& ds2
 583 )
 584 {
 585     return ds1*ds2;
 586 }
 587
 588
 589 Foam::dimensionSet Foam::operator^
 590 (
 591     const dimensionSet& ds1,
 592     const dimensionSet& ds2
 593 )
 594 {
 595     return ds1*ds2;
 596 }
 597
 598
 599 Foam::dimensionSet Foam::operator&&
 600 (
 601     const dimensionSet& ds1,
 602     const dimensionSet& ds2
 603 )
 604 {
 605     return ds1*ds2;
 606 }
 607
 608
 609 // ************************************************************************* //