src/OpenFOAM/dimensionSet/dimensionSet.C

   1 /*---------------------------------------------------------------------------*\
   2   =========                 |
   3   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
   4    \\    /   O peration     |
   5     \\  /    A nd           | Copyright held by original author
   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 "dimensionSet.H"
  28 #include "dimensionedScalar.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     bool Dimensionless = true;
  83
  84     for (int Dimension=0; Dimension<nDimensions; Dimension++)
  85     {
  86         Dimensionless = Dimensionless &&
  87         (
  88             exponents_[Dimension] < smallExponent
  89          && exponents_[Dimension] > -smallExponent
  90         );
  91     }
  92
  93     return Dimensionless;
  94 }
  95
  96
  97 void Foam::dimensionSet::reset(const dimensionSet& ds)
  98 {
  99     for (int Dimension=0; Dimension<nDimensions; Dimension++)
 100     {
 101         exponents_[Dimension] = ds.exponents_[Dimension];
 102     }
 103 }
 104
 105
 106 // * * * * * * * * * * * * * * * Member Operators  * * * * * * * * * * * * * //
 107
 108 Foam::scalar Foam::dimensionSet::operator[](const dimensionType type) const
 109 {
 110     return exponents_[type];
 111 }
 112
 113 Foam::scalar& Foam::dimensionSet::operator[](const dimensionType type)
 114 {
 115     return exponents_[type];
 116 }
 117
 118
 119 bool Foam::dimensionSet::operator==(const dimensionSet& ds) const
 120 {
 121     bool equall = true;
 122
 123     for (int Dimension=0; Dimension<nDimensions; Dimension++)
 124     {
 125         equall = equall &&
 126             (mag(exponents_[Dimension] - ds.exponents_[Dimension])
 127           < smallExponent);
 128     }
 129
 130     return equall;
 131 }
 132
 133 bool Foam::dimensionSet::operator!=(const dimensionSet& ds) const
 134 {
 135     return !(operator==(ds));
 136 }
 137
 138
 139 bool Foam::dimensionSet::operator=(const dimensionSet& ds) const
 140 {
 141     if (dimensionSet::debug && *this != ds)
 142     {
 143         FatalErrorIn("dimensionSet::operator=(const dimensionSet& ds) const")
 144             << "Different dimensions for =" << endl
 145             << "     dimensions : " << *this << " = " << ds << endl
 146             << abort(FatalError);
 147     }
 148
 149     return true;
 150 }
 151
 152
 153 bool Foam::dimensionSet::operator+=(const dimensionSet& ds) const
 154 {
 155     if (dimensionSet::debug && *this != ds)
 156     {
 157         FatalErrorIn("dimensionSet::operator+=(const dimensionSet& ds) const")
 158             << "Different dimensions for +=" << endl
 159             << "     dimensions : " << *this << " = " << ds << endl
 160             << abort(FatalError);
 161     }
 162
 163     return true;
 164 }
 165
 166 bool Foam::dimensionSet::operator-=(const dimensionSet& ds) const
 167 {
 168     if (dimensionSet::debug && *this != ds)
 169     {
 170         FatalErrorIn("dimensionSet::operator-=(const dimensionSet& ds) const")
 171             << "Different dimensions for -=" << endl
 172             << "     dimensions : " << *this << " = " << ds << endl
 173             << abort(FatalError);
 174     }
 175
 176     return true;
 177 }
 178
 179 bool Foam::dimensionSet::operator*=(const dimensionSet& ds)
 180 {
 181     reset((*this)*ds);
 182
 183     return true;
 184 }
 185
 186 bool Foam::dimensionSet::operator/=(const dimensionSet& ds)
 187 {
 188     reset((*this)/ds);
 189
 190     return true;
 191 }
 192
 193
 194 // * * * * * * * * * * * * * * * Friend functions * * * * * * * * * * * * * * //
 195
 196 Foam::dimensionSet Foam::max(const dimensionSet& ds1, const dimensionSet& ds2)
 197 {
 198     if (dimensionSet::debug && ds1 != ds2)
 199     {
 200         FatalErrorIn("max(const dimensionSet& ds1, const dimensionSet& ds2)")
 201             << "Arguments of max have different dimensions" << endl
 202             << "     dimensions : " << ds1 << " and " << ds2 << endl
 203             << abort(FatalError);
 204     }
 205
 206     return ds1;
 207 }
 208
 209 Foam::dimensionSet Foam::min(const dimensionSet& ds1, const dimensionSet& ds2)
 210 {
 211     if (dimensionSet::debug && ds1 != ds2)
 212     {
 213         FatalErrorIn("min(const dimensionSet& ds1, const dimensionSet& ds2)")
 214             << "Arguments of min have different dimensions" << endl
 215             << "     dimensions : " << ds1 << " and " << ds2 << endl
 216             << abort(FatalError);
 217     }
 218
 219     return ds1;
 220 }
 221
 222
 223 Foam::dimensionSet Foam::cmptMultiply
 224 (
 225     const dimensionSet& ds1,
 226     const dimensionSet& ds2
 227 )
 228 {
 229     return ds1*ds2;
 230 }
 231
 232
 233 Foam::dimensionSet Foam::cmptDivide
 234 (
 235     const dimensionSet& ds1,
 236     const dimensionSet& ds2
 237 )
 238 {
 239     return ds1/ds2;
 240 }
 241
 242
 243 Foam::dimensionSet Foam::pow(const dimensionSet& ds, const scalar p)
 244 {
 245     dimensionSet dimPow
 246     (
 247         ds[dimensionSet::MASS]*p,
 248         ds[dimensionSet::LENGTH]*p,
 249         ds[dimensionSet::TIME]*p,
 250         ds[dimensionSet::TEMPERATURE]*p,
 251         ds[dimensionSet::MOLES]*p,
 252         ds[dimensionSet::CURRENT]*p,
 253         ds[dimensionSet::LUMINOUS_INTENSITY]*p
 254     );
 255
 256     return dimPow;
 257 }
 258
 259 Foam::dimensionSet Foam::pow
 260 (
 261     const dimensionSet& ds,
 262     const dimensionedScalar& dS
 263 )
 264 {
 265     if (dimensionSet::debug && !dS.dimensions().dimensionless())
 266     {
 267         FatalErrorIn("pow(const dimensionSet& ds, const dimensionedScalar& dS)")
 268             << "Exponent of pow are not dimensionless"
 269             << abort(FatalError);
 270     }
 271
 272     dimensionSet dimPow
 273     (
 274         ds[dimensionSet::MASS]*dS.value(),
 275         ds[dimensionSet::LENGTH]*dS.value(),
 276         ds[dimensionSet::TIME]*dS.value(),
 277         ds[dimensionSet::TEMPERATURE]*dS.value(),
 278         ds[dimensionSet::MOLES]*dS.value(),
 279         ds[dimensionSet::CURRENT]*dS.value(),
 280         ds[dimensionSet::LUMINOUS_INTENSITY]*dS.value()
 281     );
 282
 283     return dimPow;
 284 }
 285
 286 Foam::dimensionSet Foam::pow
 287 (
 288     const dimensionedScalar& dS,
 289     const dimensionSet& ds
 290 )
 291 {
 292     if
 293     (
 294         dimensionSet::debug
 295      && !dS.dimensions().dimensionless()
 296      && !ds.dimensionless())
 297     {
 298         FatalErrorIn("pow(const dimensionedScalar& dS, const dimensionSet& ds)")
 299             << "Argument or exponent of pow not dimensionless" << endl
 300             << abort(FatalError);
 301     }
 302
 303     return ds;
 304 }
 305
 306
 307 Foam::dimensionSet Foam::sqr(const dimensionSet& ds)
 308 {
 309     return pow(ds, 2);
 310 }
 311
 312 Foam::dimensionSet Foam::pow3(const dimensionSet& ds)
 313 {
 314     return pow(ds, 3);
 315 }
 316
 317 Foam::dimensionSet Foam::pow4(const dimensionSet& ds)
 318 {
 319     return pow(ds, 4);
 320 }
 321
 322 Foam::dimensionSet Foam::pow5(const dimensionSet& ds)
 323 {
 324     return pow(ds, 5);
 325 }
 326
 327 Foam::dimensionSet Foam::pow6(const dimensionSet& ds)
 328 {
 329     return pow(ds, 6);
 330 }
 331
 332 Foam::dimensionSet Foam::sqrt(const dimensionSet& ds)
 333 {
 334     return pow(ds, 0.5);
 335 }
 336
 337 Foam::dimensionSet Foam::magSqr(const dimensionSet& ds)
 338 {
 339     return pow(ds, 2);
 340 }
 341
 342 Foam::dimensionSet Foam::mag(const dimensionSet& ds)
 343 {
 344     return ds;
 345 }
 346
 347 Foam::dimensionSet Foam::sign(const dimensionSet&)
 348 {
 349     return dimless;
 350 }
 351
 352 Foam::dimensionSet Foam::pos(const dimensionSet&)
 353 {
 354     return dimless;
 355 }
 356
 357 Foam::dimensionSet Foam::neg(const dimensionSet&)
 358 {
 359     return dimless;
 360 }
 361
 362 Foam::dimensionSet Foam::inv(const dimensionSet& ds)
 363 {
 364     return dimless/ds;
 365 }
 366
 367 Foam::dimensionSet Foam::hinv(const dimensionSet& ds)
 368 {
 369     return inv(ds);
 370 }
 371
 372 Foam::dimensionSet Foam::trans(const dimensionSet& ds)
 373 {
 374     if (dimensionSet::debug && !ds.dimensionless())
 375     {
 376         FatalErrorIn("trans(const dimensionSet& ds)")
 377             << "Argument of trancendental function not dimensionless"
 378             << abort(FatalError);
 379     }
 380
 381     return ds;
 382 }
 383
 384 Foam::dimensionSet Foam::transform(const dimensionSet& ds)
 385 {
 386     return ds;
 387 }
 388
 389
 390 // * * * * * * * * * * * * * * * Friend Operators  * * * * * * * * * * * * * //
 391
 392 Foam::dimensionSet Foam::operator-(const dimensionSet& ds)
 393 {
 394     return ds;
 395 }
 396
 397 Foam::dimensionSet Foam::operator+
 398 (
 399     const dimensionSet& ds1,
 400     const dimensionSet& ds2
 401 )
 402 {
 403     dimensionSet dimSum(ds1);
 404
 405     if (dimensionSet::debug && ds1 != ds2)
 406     {
 407         FatalErrorIn
 408             ("operator+(const dimensionSet& ds1, const dimensionSet& ds2)")
 409             << "LHS and RHS of + have different dimensions" << endl
 410             << "     dimensions : " << ds1 << " + " << ds2 << endl
 411             << abort(FatalError);
 412     }
 413
 414     return dimSum;
 415 }
 416
 417 Foam::dimensionSet Foam::operator-
 418 (
 419     const dimensionSet& ds1,
 420     const dimensionSet& ds2
 421 )
 422 {
 423     dimensionSet dimDifference(ds1);
 424
 425     if (dimensionSet::debug && ds1 != ds2)
 426     {
 427         FatalErrorIn
 428             ("operator-(const dimensionSet& ds1, const dimensionSet& ds2)")
 429             << "LHS and RHS of - have different dimensions" << endl
 430             << "     dimensions : " << ds1 << " - " << ds2 << endl
 431             << abort(FatalError);
 432     }
 433
 434     return dimDifference;
 435 }
 436
 437 Foam::dimensionSet Foam::operator*
 438 (
 439     const dimensionSet& ds1,
 440     const dimensionSet& ds2
 441 )
 442 {
 443     dimensionSet dimProduct(ds1);
 444
 445     for (int Dimension=0; Dimension<dimensionSet::nDimensions; Dimension++)
 446     {
 447         dimProduct.exponents_[Dimension] += ds2.exponents_[Dimension];
 448     }
 449
 450     return dimProduct;
 451 }
 452
 453 Foam::dimensionSet Foam::operator/
 454 (
 455     const dimensionSet& ds1,
 456     const dimensionSet& ds2
 457 )
 458 {
 459     dimensionSet dimQuotient(ds1);
 460
 461     for (int Dimension=0; Dimension<dimensionSet::nDimensions; Dimension++)
 462     {
 463         dimQuotient.exponents_[Dimension] -= ds2.exponents_[Dimension];
 464     }
 465
 466     return dimQuotient;
 467 }
 468
 469
 470 Foam::dimensionSet Foam::operator&
 471 (
 472     const dimensionSet& ds1,
 473     const dimensionSet& ds2
 474 )
 475 {
 476     return ds1*ds2;
 477 }
 478
 479 Foam::dimensionSet Foam::operator^
 480 (
 481     const dimensionSet& ds1,
 482     const dimensionSet& ds2
 483 )
 484 {
 485     return ds1*ds2;
 486 }
 487
 488 Foam::dimensionSet Foam::operator&&
 489 (
 490     const dimensionSet& ds1,
 491     const dimensionSet& ds2
 492 )
 493 {
 494     return ds1*ds2;
 495 }
 496
 497
 498 // ************************************************************************* //