src/OpenFOAM/primitives/SymmTensor/SymmTensorI.H

   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 "Vector.H"
  27
  28 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
  29
  30 namespace Foam
  31 {
  32
  33 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
  34
  35 template <class Cmpt>
  36 inline SymmTensor<Cmpt>::SymmTensor()
  37 {}
  38
  39
  40 template <class Cmpt>
  41 inline SymmTensor<Cmpt>::SymmTensor
  42 (
  43     const VectorSpace<SymmTensor<Cmpt>, Cmpt, 6>& vs
  44 )
  45 :
  46     VectorSpace<SymmTensor<Cmpt>, Cmpt, 6>(vs)
  47 {}
  48
  49
  50 template <class Cmpt>
  51 inline SymmTensor<Cmpt>::SymmTensor(const SphericalTensor<Cmpt>& st)
  52 {
  53     this->v_[XX] = st.ii(); this->v_[XY] = 0;       this->v_[XZ] = 0;
  54                             this->v_[YY] = st.ii(); this->v_[YZ] = 0;
  55                                                     this->v_[ZZ] = st.ii();
  56 }
  57
  58
  59 template <class Cmpt>
  60 inline SymmTensor<Cmpt>::SymmTensor
  61 (
  62     const Cmpt txx, const Cmpt txy, const Cmpt txz,
  63                     const Cmpt tyy, const Cmpt tyz,
  64                                     const Cmpt tzz
  65 )
  66 {
  67     this->v_[XX] = txx; this->v_[XY] = txy; this->v_[XZ] = txz;
  68                         this->v_[YY] = tyy; this->v_[YZ] = tyz;
  69                                             this->v_[ZZ] = tzz;
  70 }
  71
  72
  73 template <class Cmpt>
  74 inline SymmTensor<Cmpt>::SymmTensor(Istream& is)
  75 :
  76     VectorSpace<SymmTensor<Cmpt>, Cmpt, 6>(is)
  77 {}
  78
  79
  80 // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
  81
  82 template <class Cmpt>
  83 inline const Cmpt&  SymmTensor<Cmpt>::xx() const
  84 {
  85     return this->v_[XX];
  86 }
  87
  88 template <class Cmpt>
  89 inline const Cmpt&  SymmTensor<Cmpt>::xy() const
  90 {
  91     return this->v_[XY];
  92 }
  93
  94 template <class Cmpt>
  95 inline const Cmpt&  SymmTensor<Cmpt>::xz() const
  96 {
  97     return this->v_[XZ];
  98 }
  99
 100 template <class Cmpt>
 101 inline const Cmpt&  SymmTensor<Cmpt>::yy() const
 102 {
 103     return this->v_[YY];
 104 }
 105
 106 template <class Cmpt>
 107 inline const Cmpt&  SymmTensor<Cmpt>::yz() const
 108 {
 109     return this->v_[YZ];
 110 }
 111
 112 template <class Cmpt>
 113 inline const Cmpt&  SymmTensor<Cmpt>::zz() const
 114 {
 115     return this->v_[ZZ];
 116 }
 117
 118
 119 template <class Cmpt>
 120 inline Cmpt& SymmTensor<Cmpt>::xx()
 121 {
 122     return this->v_[XX];
 123 }
 124
 125 template <class Cmpt>
 126 inline Cmpt& SymmTensor<Cmpt>::xy()
 127 {
 128     return this->v_[XY];
 129 }
 130
 131 template <class Cmpt>
 132 inline Cmpt& SymmTensor<Cmpt>::xz()
 133 {
 134     return this->v_[XZ];
 135 }
 136
 137 template <class Cmpt>
 138 inline Cmpt& SymmTensor<Cmpt>::yy()
 139 {
 140     return this->v_[YY];
 141 }
 142
 143 template <class Cmpt>
 144 inline Cmpt& SymmTensor<Cmpt>::yz()
 145 {
 146     return this->v_[YZ];
 147 }
 148
 149 template <class Cmpt>
 150 inline Cmpt& SymmTensor<Cmpt>::zz()
 151 {
 152     return this->v_[ZZ];
 153 }
 154
 155
 156 template <class Cmpt>
 157 inline const SymmTensor<Cmpt>& SymmTensor<Cmpt>::T() const
 158 {
 159     return *this;
 160 }
 161
 162
 163 // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
 164
 165 template <class Cmpt>
 166 inline void SymmTensor<Cmpt>::operator=(const SphericalTensor<Cmpt>& st)
 167 {
 168     this->v_[XX] = st.ii(); this->v_[XY] = 0;       this->v_[XZ] = 0;
 169                             this->v_[YY] = st.ii(); this->v_[YZ] = 0;
 170                                                     this->v_[ZZ] = st.ii();
 171 }
 172
 173
 174
 175 // * * * * * * * * * * * * * * * Global Operators  * * * * * * * * * * * * * //
 176
 177 //- Hodge Dual operator (tensor -> vector)
 178 template <class Cmpt>
 179 inline Vector<Cmpt> operator*(const SymmTensor<Cmpt>& st)
 180 {
 181     return Vector<Cmpt>(st.yz(), -st.xz(), st.xy());
 182 }
 183
 184
 185 //- Inner-product between two symmetric tensors
 186 template <class Cmpt>
 187 inline SymmTensor<Cmpt>
 188 operator&(const SymmTensor<Cmpt>& st1, const SymmTensor<Cmpt>& st2)
 189 {
 190     return SymmTensor<Cmpt>
 191     (
 192         st1.xx()*st2.xx() + st1.xy()*st2.xy() + st1.xz()*st2.xz(),
 193         st1.xx()*st2.xy() + st1.xy()*st2.yy() + st1.xz()*st2.yz(),
 194         st1.xx()*st2.xz() + st1.xy()*st2.yz() + st1.xz()*st2.zz(),
 195
 196         st1.xy()*st2.xy() + st1.yy()*st2.yy() + st1.yz()*st2.yz(),
 197         st1.xy()*st2.xz() + st1.yy()*st2.yz() + st1.yz()*st2.zz(),
 198
 199         st1.xz()*st2.xz() + st1.yz()*st2.yz() + st1.zz()*st2.zz()
 200     );
 201 }
 202
 203
 204 //- Double-dot-product between a symmetric tensor and a symmetric tensor
 205 template <class Cmpt>
 206 inline Cmpt
 207 operator&&(const SymmTensor<Cmpt>& st1, const SymmTensor<Cmpt>& st2)
 208 {
 209     return
 210     (
 211         st1.xx()*st2.xx() + 2*st1.xy()*st2.xy() + 2*st1.xz()*st2.xz()
 212                           +   st1.yy()*st2.yy() + 2*st1.yz()*st2.yz()
 213                                                 +   st1.zz()*st2.zz()
 214     );
 215 }
 216
 217
 218 //- Inner-product between a symmetric tensor and a vector
 219 template <class Cmpt>
 220 inline Vector<Cmpt>
 221 operator&(const SymmTensor<Cmpt>& st, const Vector<Cmpt>& v)
 222 {
 223     return Vector<Cmpt>
 224     (
 225         st.xx()*v.x() + st.xy()*v.y() + st.xz()*v.z(),
 226         st.xy()*v.x() + st.yy()*v.y() + st.yz()*v.z(),
 227         st.xz()*v.x() + st.yz()*v.y() + st.zz()*v.z()
 228     );
 229 }
 230
 231
 232 //- Inner-product between a vector and a symmetric tensor
 233 template <class Cmpt>
 234 inline Vector<Cmpt>
 235 operator&(const Vector<Cmpt>& v, const SymmTensor<Cmpt>& st)
 236 {
 237     return Vector<Cmpt>
 238     (
 239         v.x()*st.xx() + v.y()*st.xy() + v.z()*st.xz(),
 240         v.x()*st.xy() + v.y()*st.yy() + v.z()*st.yz(),
 241         v.x()*st.xz() + v.y()*st.yz() + v.z()*st.zz()
 242     );
 243 }
 244
 245
 246 template <class Cmpt>
 247 inline Cmpt magSqr(const SymmTensor<Cmpt>& st)
 248 {
 249     return
 250     (
 251         magSqr(st.xx()) + 2*magSqr(st.xy()) + 2*magSqr(st.xz())
 252                         +   magSqr(st.yy()) + 2*magSqr(st.yz())
 253                                             +   magSqr(st.zz())
 254     );
 255 }
 256
 257
 258 //- Return the trace of a symmetric tensor
 259 template <class Cmpt>
 260 inline Cmpt tr(const SymmTensor<Cmpt>& st)
 261 {
 262     return st.xx() + st.yy() + st.zz();
 263 }
 264
 265
 266 //- Return the spherical part of a symmetric tensor
 267 template <class Cmpt>
 268 inline SphericalTensor<Cmpt> sph(const SymmTensor<Cmpt>& st)
 269 {
 270     return (1.0/3.0)*tr(st);
 271 }
 272
 273
 274 //- Return the symmetric part of a symmetric tensor, i.e. itself
 275 template <class Cmpt>
 276 inline const SymmTensor<Cmpt>& symm(const SymmTensor<Cmpt>& st)
 277 {
 278     return st;
 279 }
 280
 281
 282 //- Return twice the symmetric part of a symmetric tensor
 283 template <class Cmpt>
 284 inline SymmTensor<Cmpt> twoSymm(const SymmTensor<Cmpt>& st)
 285 {
 286     return 2*st;
 287 }
 288
 289
 290 //- Return the deviatoric part of a symmetric tensor
 291 template <class Cmpt>
 292 inline SymmTensor<Cmpt> dev(const SymmTensor<Cmpt>& st)
 293 {
 294     return st - SphericalTensor<Cmpt>::oneThirdI*tr(st);
 295 }
 296
 297
 298 //- Return the deviatoric part of a symmetric tensor
 299 template <class Cmpt>
 300 inline SymmTensor<Cmpt> dev2(const SymmTensor<Cmpt>& st)
 301 {
 302     return st - SphericalTensor<Cmpt>::twoThirdsI*tr(st);
 303 }
 304
 305
 306 //- Return the determinant of a symmetric tensor
 307 template <class Cmpt>
 308 inline Cmpt det(const SymmTensor<Cmpt>& st)
 309 {
 310     return
 311     (
 312         st.xx()*st.yy()*st.zz() + st.xy()*st.yz()*st.xz()
 313       + st.xz()*st.xy()*st.yz() - st.xx()*st.yz()*st.yz()
 314       - st.xy()*st.xy()*st.zz() - st.xz()*st.yy()*st.xz()
 315     );
 316 }
 317
 318
 319 //- Return the cofactor symmetric tensor of a symmetric tensor
 320 template <class Cmpt>
 321 inline SymmTensor<Cmpt> cof(const SymmTensor<Cmpt>& st)
 322 {
 323     return SymmTensor<Cmpt>
 324     (
 325         st.yy()*st.zz() - st.yz()*st.yz(),
 326         st.xz()*st.yz() - st.xy()*st.zz(),
 327         st.xy()*st.yz() - st.xz()*st.yy(),
 328
 329         st.xx()*st.zz() - st.xz()*st.xz(),
 330         st.xy()*st.xz() - st.xx()*st.yz(),
 331
 332         st.xx()*st.yy() - st.xy()*st.xy()
 333     );
 334 }
 335
 336
 337 //- Return the inverse of a symmetric tensor give the determinant
 338 template <class Cmpt>
 339 inline SymmTensor<Cmpt> inv(const SymmTensor<Cmpt>& st, const Cmpt detst)
 340 {
 341     return SymmTensor<Cmpt>
 342     (
 343         st.yy()*st.zz() - st.yz()*st.yz(),
 344         st.xz()*st.yz() - st.xy()*st.zz(),
 345         st.xy()*st.yz() - st.xz()*st.yy(),
 346
 347         st.xx()*st.zz() - st.xz()*st.xz(),
 348         st.xy()*st.xz() - st.xx()*st.yz(),
 349
 350         st.xx()*st.yy() - st.xy()*st.xy()
 351     )/detst;
 352 }
 353
 354
 355 //- Return the inverse of a symmetric tensor
 356 template <class Cmpt>
 357 inline SymmTensor<Cmpt> inv(const SymmTensor<Cmpt>& st)
 358 {
 359     return inv(st, det(st));
 360 }
 361
 362
 363 //- Return the 1st invariant of a symmetric tensor
 364 template <class Cmpt>
 365 inline Cmpt invariantI(const SymmTensor<Cmpt>& st)
 366 {
 367     return tr(st);
 368 }
 369
 370
 371 //- Return the 2nd invariant of a symmetric tensor
 372 template <class Cmpt>
 373 inline Cmpt invariantII(const SymmTensor<Cmpt>& st)
 374 {
 375     return
 376     (
 377         0.5*sqr(tr(st))
 378       - 0.5*
 379         (
 380            st.xx()*st.xx() + st.xy()*st.xy() + st.xz()*st.xz()
 381          + st.xy()*st.xy() + st.yy()*st.yy() + st.yz()*st.yz()
 382          + st.xz()*st.xz() + st.yz()*st.yz() + st.zz()*st.zz()
 383         )
 384     );
 385 }
 386
 387
 388 //- Return the 3rd invariant of a symmetric tensor
 389 template <class Cmpt>
 390 inline Cmpt invariantIII(const SymmTensor<Cmpt>& st)
 391 {
 392     return det(st);
 393 }
 394
 395
 396 template <class Cmpt>
 397 inline SymmTensor<Cmpt>
 398 operator+(const SphericalTensor<Cmpt>& spt1, const SymmTensor<Cmpt>& st2)
 399 {
 400     return SymmTensor<Cmpt>
 401     (
 402         spt1.ii() + st2.xx(), st2.xy(),             st2.xz(),
 403                               spt1.ii() + st2.yy(), st2.yz(),
 404                                                     spt1.ii() + st2.zz()
 405     );
 406 }
 407
 408
 409 template <class Cmpt>
 410 inline SymmTensor<Cmpt>
 411 operator+(const SymmTensor<Cmpt>& st1, const SphericalTensor<Cmpt>& spt2)
 412 {
 413     return SymmTensor<Cmpt>
 414     (
 415         st1.xx() + spt2.ii(), st1.xy(),             st1.xz(),
 416                               st1.yy() + spt2.ii(), st1.yz(),
 417                                                     st1.zz() + spt2.ii()
 418     );
 419 }
 420
 421
 422 template <class Cmpt>
 423 inline SymmTensor<Cmpt>
 424 operator-(const SphericalTensor<Cmpt>& spt1, const SymmTensor<Cmpt>& st2)
 425 {
 426     return SymmTensor<Cmpt>
 427     (
 428         spt1.ii() - st2.xx(), -st2.xy(),             -st2.xz(),
 429                                spt1.ii() - st2.yy(), -st2.yz(),
 430                                                       spt1.ii() - st2.zz()
 431     );
 432 }
 433
 434
 435 template <class Cmpt>
 436 inline SymmTensor<Cmpt>
 437 operator-(const SymmTensor<Cmpt>& st1, const SphericalTensor<Cmpt>& spt2)
 438 {
 439     return SymmTensor<Cmpt>
 440     (
 441         st1.xx() - spt2.ii(), st1.xy(),             st1.xz(),
 442                               st1.yy() - spt2.ii(), st1.yz(),
 443                                                     st1.zz() - spt2.ii()
 444     );
 445 }
 446
 447
 448 //- Inner-product between a spherical symmetric tensor and a symmetric tensor
 449 template <class Cmpt>
 450 inline SymmTensor<Cmpt>
 451 operator&(const SphericalTensor<Cmpt>& spt1, const SymmTensor<Cmpt>& st2)
 452 {
 453     return SymmTensor<Cmpt>
 454     (
 455         spt1.ii()*st2.xx(), spt1.ii()*st2.xy(), spt1.ii()*st2.xz(),
 456                             spt1.ii()*st2.yy(), spt1.ii()*st2.yz(),
 457                                                 spt1.ii()*st2.zz()
 458     );
 459 }
 460
 461
 462 //- Inner-product between a tensor and a spherical tensor
 463 template <class Cmpt>
 464 inline SymmTensor<Cmpt>
 465 operator&(const SymmTensor<Cmpt>& st1, const SphericalTensor<Cmpt>& spt2)
 466 {
 467     return SymmTensor<Cmpt>
 468     (
 469         st1.xx()*spt2.ii(), st1.xy()*spt2.ii(), st1.xz()*spt2.ii(),
 470                             st1.yy()*spt2.ii(), st1.yz()*spt2.ii(),
 471                                                 st1.zz()*spt2.ii()
 472     );
 473 }
 474
 475
 476 //- Double-dot-product between a spherical tensor and a symmetric tensor
 477 template <class Cmpt>
 478 inline Cmpt
 479 operator&&(const SphericalTensor<Cmpt>& spt1, const SymmTensor<Cmpt>& st2)
 480 {
 481     return(spt1.ii()*st2.xx() + spt1.ii()*st2.yy() + spt1.ii()*st2.zz());
 482 }
 483
 484
 485 //- Double-dot-product between a tensor and a spherical tensor
 486 template <class Cmpt>
 487 inline Cmpt
 488 operator&&(const SymmTensor<Cmpt>& st1, const SphericalTensor<Cmpt>& spt2)
 489 {
 490     return(st1.xx()*spt2.ii() + st1.yy()*spt2.ii() + st1.zz()*spt2.ii());
 491 }
 492
 493
 494 template <class Cmpt>
 495 inline SymmTensor<Cmpt> sqr(const Vector<Cmpt>& v)
 496 {
 497     return SymmTensor<Cmpt>
 498     (
 499         v.x()*v.x(), v.x()*v.y(), v.x()*v.z(),
 500                      v.y()*v.y(), v.y()*v.z(),
 501                                   v.z()*v.z()
 502     );
 503 }
 504
 505
 506 template<class Cmpt>
 507 class outerProduct<SymmTensor<Cmpt>, Cmpt>
 508 {
 509 public:
 510
 511     typedef SymmTensor<Cmpt> type;
 512 };
 513
 514 template<class Cmpt>
 515 class outerProduct<Cmpt, SymmTensor<Cmpt> >
 516 {
 517 public:
 518
 519     typedef SymmTensor<Cmpt> type;
 520 };
 521
 522 template<class Cmpt>
 523 class innerProduct<SymmTensor<Cmpt>, SymmTensor<Cmpt> >
 524 {
 525 public:
 526
 527     typedef SymmTensor<Cmpt> type;
 528 };
 529
 530 template<class Cmpt>
 531 class innerProduct<SymmTensor<Cmpt>, Vector<Cmpt> >
 532 {
 533 public:
 534
 535     typedef Vector<Cmpt> type;
 536 };
 537
 538 template<class Cmpt>
 539 class innerProduct<Vector<Cmpt>, SymmTensor<Cmpt> >
 540 {
 541 public:
 542
 543     typedef Vector<Cmpt> type;
 544 };
 545
 546
 547 template<class Cmpt>
 548 class typeOfSum<SphericalTensor<Cmpt>, SymmTensor<Cmpt> >
 549 {
 550 public:
 551
 552     typedef SymmTensor<Cmpt> type;
 553 };
 554
 555 template<class Cmpt>
 556 class typeOfSum<SymmTensor<Cmpt>, SphericalTensor<Cmpt> >
 557 {
 558 public:
 559
 560     typedef SymmTensor<Cmpt> type;
 561 };
 562
 563 template<class Cmpt>
 564 class innerProduct<SphericalTensor<Cmpt>, SymmTensor<Cmpt> >
 565 {
 566 public:
 567
 568     typedef SymmTensor<Cmpt> type;
 569 };
 570
 571 template<class Cmpt>
 572 class innerProduct<SymmTensor<Cmpt>, SphericalTensor<Cmpt> >
 573 {
 574 public:
 575
 576     typedef SymmTensor<Cmpt> type;
 577 };
 578
 579
 580 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 581
 582 } // End namespace Foam
 583
 584 // ************************************************************************* //