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