src/OpenFOAM/dimensionSet/dimensionSet.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 "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::trans(const dimensionSet& ds)
 368 {
 369     if (dimensionSet::debug && !ds.dimensionless())
 370     {
 371         FatalErrorIn("trans(const dimensionSet& ds)")
 372             << "Argument of trancendental function not dimensionless"
 373             << abort(FatalError);
 374     }
 375
 376     return ds;
 377 }
 378
 379 Foam::dimensionSet Foam::transform(const dimensionSet& ds)
 380 {
 381     return ds;
 382 }
 383
 384
 385 // * * * * * * * * * * * * * * * Friend Operators  * * * * * * * * * * * * * //
 386
 387 Foam::dimensionSet Foam::operator-(const dimensionSet& ds)
 388 {
 389     return ds;
 390 }
 391
 392 Foam::dimensionSet Foam::operator+
 393 (
 394     const dimensionSet& ds1,
 395     const dimensionSet& ds2
 396 )
 397 {
 398     dimensionSet dimSum(ds1);
 399
 400     if (dimensionSet::debug && ds1 != ds2)
 401     {
 402         FatalErrorIn
 403             ("operator+(const dimensionSet& ds1, const dimensionSet& ds2)")
 404             << "LHS and RHS of + have different dimensions" << endl
 405             << "     dimensions : " << ds1 << " + " << ds2 << endl
 406             << abort(FatalError);
 407     }
 408
 409     return dimSum;
 410 }
 411
 412 Foam::dimensionSet Foam::operator-
 413 (
 414     const dimensionSet& ds1,
 415     const dimensionSet& ds2
 416 )
 417 {
 418     dimensionSet dimDifference(ds1);
 419
 420     if (dimensionSet::debug && ds1 != ds2)
 421     {
 422         FatalErrorIn
 423             ("operator-(const dimensionSet& ds1, const dimensionSet& ds2)")
 424             << "LHS and RHS of - have different dimensions" << endl
 425             << "     dimensions : " << ds1 << " - " << ds2 << endl
 426             << abort(FatalError);
 427     }
 428
 429     return dimDifference;
 430 }
 431
 432 Foam::dimensionSet Foam::operator*
 433 (
 434     const dimensionSet& ds1,
 435     const dimensionSet& ds2
 436 )
 437 {
 438     dimensionSet dimProduct(ds1);
 439
 440     for (int Dimension=0; Dimension<dimensionSet::nDimensions; Dimension++)
 441     {
 442         dimProduct.exponents_[Dimension] += ds2.exponents_[Dimension];
 443     }
 444
 445     return dimProduct;
 446 }
 447
 448 Foam::dimensionSet Foam::operator/
 449 (
 450     const dimensionSet& ds1,
 451     const dimensionSet& ds2
 452 )
 453 {
 454     dimensionSet dimQuotient(ds1);
 455
 456     for (int Dimension=0; Dimension<dimensionSet::nDimensions; Dimension++)
 457     {
 458         dimQuotient.exponents_[Dimension] -= ds2.exponents_[Dimension];
 459     }
 460
 461     return dimQuotient;
 462 }
 463
 464
 465 Foam::dimensionSet Foam::operator&
 466 (
 467     const dimensionSet& ds1,
 468     const dimensionSet& ds2
 469 )
 470 {
 471     return ds1*ds2;
 472 }
 473
 474 Foam::dimensionSet Foam::operator^
 475 (
 476     const dimensionSet& ds1,
 477     const dimensionSet& ds2
 478 )
 479 {
 480     return ds1*ds2;
 481 }
 482
 483 Foam::dimensionSet Foam::operator&&
 484 (
 485     const dimensionSet& ds1,
 486     const dimensionSet& ds2
 487 )
 488 {
 489     return ds1*ds2;
 490 }
 491
 492
 493 // ************************************************************************* //