src/foam/primitives/VectorN/DiagTensorNI.H

   1 /*---------------------------------------------------------------------------*\
   2   =========                 |
   3   \\      /  F ield         | foam-extend: Open Source CFD
   4    \\    /   O peration     | Version:     3.2
   5     \\  /    A nd           | Web:         http://www.foam-extend.org
   6      \\/     M anipulation  | For copyright notice see file Copyright
   7 -------------------------------------------------------------------------------
   8 License
   9     This file is part of foam-extend.
  10
  11     foam-extend 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 3 of the License, or (at your
  14     option) any later version.
  15
  16     foam-extend is distributed in the hope that it will be useful, but
  17     WITHOUT ANY WARRANTY; without even the implied warranty of
  18     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  19     General Public License for more details.
  20
  21     You should have received a copy of the GNU General Public License
  22     along with foam-extend.  If not, see <http://www.gnu.org/licenses/>.
  23
  24 \*---------------------------------------------------------------------------*/
  25
  26 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
  27
  28 namespace Foam
  29 {
  30
  31 // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
  32
  33 template <class Cmpt, int length>
  34 const char* const DiagTensorN<Cmpt, length>::typeName =
  35     ("diagTensor" + name(length)).c_str();
  36
  37 template <class Cmpt, int length>
  38 const DiagTensorN<Cmpt, length> DiagTensorN<Cmpt, length>::zero(0);
  39
  40 template <class Cmpt, int length>
  41 const DiagTensorN<Cmpt, length> DiagTensorN<Cmpt, length>::one(1);
  42
  43
  44 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
  45
  46 // Construct null
  47 template <class Cmpt, int length>
  48 inline DiagTensorN<Cmpt, length>::DiagTensorN()
  49 {}
  50
  51
  52 // Construct given VectorSpace
  53 template <class Cmpt, int length>
  54 inline DiagTensorN<Cmpt, length>::DiagTensorN
  55 (
  56     const VectorSpace<DiagTensorN<Cmpt, length>, Cmpt, length>& vs
  57 )
  58 :
  59     VectorSpace<DiagTensorN<Cmpt, length>, Cmpt, length>(vs)
  60 {}
  61
  62
  63 //- Construct from component
  64 template <class Cmpt, int length>
  65 inline DiagTensorN<Cmpt, length>::DiagTensorN(const Cmpt& tx)
  66 {
  67     VectorSpaceOps<DiagTensorN<Cmpt, length>::nComponents,0>::eqOpS
  68     (
  69         *this,
  70         tx,
  71         eqOp<Cmpt>()
  72     );
  73 }
  74
  75
  76 // Construct from Istream
  77 template <class Cmpt, int length>
  78 inline DiagTensorN<Cmpt, length>::DiagTensorN(Istream& is)
  79 :
  80     VectorSpace<DiagTensorN<Cmpt, length>, Cmpt, length>(is)
  81 {}
  82
  83
  84 // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
  85
  86 //- Return diagonal tensor diagonal
  87 template <class Cmpt, int length>
  88 inline DiagTensorN<Cmpt, length> DiagTensorN<Cmpt, length>::diag() const
  89 {
  90     return *this;
  91 }
  92
  93 //- Return diagonal tensor transpose
  94 template <class Cmpt, int length>
  95 inline DiagTensorN<Cmpt, length> DiagTensorN<Cmpt, length>::T() const
  96 {
  97     return *this;
  98 }
  99
 100
 101 //- Assign to a SphericalTensorN
 102 template <class Cmpt, int length>
 103 inline void DiagTensorN<Cmpt, length>::operator=
 104 (
 105     const SphericalTensorN<Cmpt, length>& st
 106 )
 107 {
 108     const Cmpt& s = st.v_[0];
 109     VectorSpaceOps<DiagTensorN<Cmpt, length>::nComponents,0>::eqOpS
 110     (
 111         *this,
 112         s,
 113         eqOp<Cmpt>()
 114     );
 115 }
 116
 117 // * * * * * * * * * * * * * * * Global Operators  * * * * * * * * * * * * * //
 118
 119 //- Addition of DiagTensorN and DiagTensorN
 120 template <class Cmpt, int length>
 121 inline DiagTensorN<Cmpt, length>
 122 operator+
 123 (
 124     const DiagTensorN<Cmpt, length>& dt1,
 125     const DiagTensorN<Cmpt, length>& dt2
 126 )
 127 {
 128     DiagTensorN<Cmpt, length> res;
 129     VectorSpaceOps<DiagTensorN<Cmpt, length>::nComponents,0>::op
 130     (
 131         res,
 132         dt1,
 133         dt2,
 134         plusOp<Cmpt>()
 135     );
 136
 137     return res;
 138 }
 139
 140
 141 //- Addition of DiagTensorN and SphericalTensorN
 142 template <class Cmpt, int length>
 143 inline DiagTensorN<Cmpt, length>
 144 operator+
 145 (
 146     const DiagTensorN<Cmpt, length>& dt1,
 147     const SphericalTensorN<Cmpt, length>& st2
 148 )
 149 {
 150     const Cmpt& s = st2.v_[0];
 151     DiagTensorN<Cmpt, length> res;
 152     VectorSpaceOps<DiagTensorN<Cmpt, length>::nComponents,0>::opVS
 153     (
 154         res,
 155         dt1,
 156         s,
 157         plusOp<Cmpt>()
 158     );
 159
 160     return res;
 161 }
 162
 163
 164 //- Addition of SphericalTensorN and DiagTensorN
 165 template <class Cmpt, int length>
 166 inline DiagTensorN<Cmpt, length>
 167 operator+
 168 (
 169     const SphericalTensorN<Cmpt, length>& st1,
 170     const DiagTensorN<Cmpt, length>& dt2
 171 )
 172 {
 173     const Cmpt& s = st1.v_[0];
 174     DiagTensorN<Cmpt, length> res;
 175     VectorSpaceOps<DiagTensorN<Cmpt, length>::nComponents,0>::opSV
 176     (
 177         res,
 178         s,
 179         dt2,
 180         plusOp<Cmpt>()
 181     );
 182
 183     return res;
 184 }
 185
 186
 187 //- Subtraction of DiagTensorN and DiagTensorN
 188 template <class Cmpt, int length>
 189 inline DiagTensorN<Cmpt, length>
 190 operator-
 191 (
 192     const DiagTensorN<Cmpt, length>& dt1,
 193     const DiagTensorN<Cmpt, length>& dt2
 194 )
 195 {
 196     DiagTensorN<Cmpt, length> res;
 197     VectorSpaceOps<DiagTensorN<Cmpt, length>::nComponents,0>::op
 198     (
 199         res,
 200         dt1,
 201         dt2,
 202         minusOp<Cmpt>()
 203     );
 204
 205     return res;
 206 }
 207
 208
 209 //- Subtraction of DiagTensorN and SphericalTensorN
 210 template <class Cmpt, int length>
 211 inline DiagTensorN<Cmpt, length>
 212 operator-
 213 (
 214     const DiagTensorN<Cmpt, length>& dt1,
 215     const SphericalTensorN<Cmpt, length>& st2
 216 )
 217 {
 218     const Cmpt& s = st2.v_[0];
 219     DiagTensorN<Cmpt, length> res;
 220     VectorSpaceOps<DiagTensorN<Cmpt, length>::nComponents,0>::opVS
 221     (
 222         res,
 223         dt1,
 224         s,
 225         minusOp<Cmpt>()
 226     );
 227
 228     return res;
 229 }
 230
 231
 232 //- Subtraction of SphericalTensorN and DiagTensorN
 233 template <class Cmpt, int length>
 234 inline DiagTensorN<Cmpt, length>
 235 operator-
 236 (
 237     const SphericalTensorN<Cmpt, length>& st1,
 238     const DiagTensorN<Cmpt, length>& dt2
 239 )
 240 {
 241     const Cmpt& s = st1.v_[0];
 242     DiagTensorN<Cmpt, length> res;
 243     VectorSpaceOps<DiagTensorN<Cmpt, length>::nComponents,0>::opSV
 244     (
 245         res,
 246         s,
 247         dt2,
 248         minusOp<Cmpt>()
 249     );
 250
 251     return res;
 252 }
 253
 254
 255 //- Inner-product between a diagonal tensor and a diagonal tensor
 256 template <class Cmpt, int length>
 257 inline typename
 258 innerProduct<DiagTensorN<Cmpt, length>, DiagTensorN<Cmpt, length> >::type
 259 operator&
 260 (
 261     const DiagTensorN<Cmpt, length>& dt1,
 262     const DiagTensorN<Cmpt, length>& dt2
 263 )
 264 {
 265     DiagTensorN<Cmpt, length> res;
 266     VectorSpaceOps<VectorN<Cmpt, length>::nComponents,0>::op
 267     (
 268         res,
 269         dt1,
 270         dt2,
 271         multiplyOp<Cmpt>()
 272     );
 273
 274     return res;
 275 }
 276
 277
 278 //- Inner-product between spherical tensor and diagonal tensor
 279 template <class Cmpt, int length>
 280 inline typename
 281 innerProduct<SphericalTensorN<Cmpt, length>, DiagTensorN<Cmpt, length> >::type
 282 operator&
 283 (
 284     const SphericalTensorN<Cmpt, length>& st1,
 285     const DiagTensorN<Cmpt, length>& dt2
 286 )
 287 {
 288     const Cmpt& s = st1.v_[0];
 289     DiagTensorN<Cmpt, length> res;
 290     VectorSpaceOps<VectorN<Cmpt, length>::nComponents,0>::opSV
 291     (
 292         res,
 293         s,
 294         dt2,
 295         multiplyOp<Cmpt>()
 296     );
 297
 298     return res;
 299 }
 300
 301
 302 //- Inner-product between diagonal tensor and spherical tensor
 303 template <class Cmpt, int length>
 304 inline typename
 305 innerProduct<DiagTensorN<Cmpt, length>, SphericalTensorN<Cmpt, length> >::type
 306 operator&
 307 (
 308     const DiagTensorN<Cmpt, length>& dt1,
 309     const SphericalTensorN<Cmpt, length>& st2
 310 )
 311 {
 312     const Cmpt& s = st2.v_[0];
 313     DiagTensorN<Cmpt, length> res;
 314     VectorSpaceOps<VectorN<Cmpt, length>::nComponents,0>::opVS
 315     (
 316         res,
 317         dt1,
 318         s,
 319         multiplyOp<Cmpt>()
 320     );
 321
 322     return res;
 323 }
 324
 325
 326 //- Inner-product between a diagonal tensor and a vector
 327 template <class Cmpt, int length>
 328 inline typename
 329 innerProduct<DiagTensorN<Cmpt, length>, VectorN<Cmpt, length> >::type
 330 operator&
 331 (
 332     const DiagTensorN<Cmpt, length>& dt,
 333     const VectorN<Cmpt, length>& v
 334 )
 335 {
 336     VectorN<Cmpt, length> res;
 337     VectorSpaceOps<VectorN<Cmpt, length>::nComponents,0>::opVV
 338     (
 339         res,
 340         dt,
 341         v,
 342         multiplyOp<Cmpt>()
 343     );
 344
 345     return res;
 346 }
 347
 348
 349
 350 //- Inner-product between a vector and a tensor
 351 template <class Cmpt, int length>
 352 inline typename
 353 innerProduct<VectorN<Cmpt, length>, DiagTensorN<Cmpt, length> >::type
 354 operator&
 355 (
 356     const VectorN<Cmpt, length>& v,
 357     const DiagTensorN<Cmpt, length>& dt
 358 )
 359 {
 360     VectorN<Cmpt, length> res;
 361     VectorSpaceOps<VectorN<Cmpt, length>::nComponents,0>::opVV
 362     (
 363         res,
 364         v,
 365         dt,
 366         multiplyOp<Cmpt>()
 367     );
 368
 369     return res;
 370 }
 371
 372
 373 //- Division of a scalar by a diagonalTensor
 374 template <class Cmpt, int length>
 375 inline DiagTensorN<Cmpt, length>
 376 operator/(const scalar s, const DiagTensorN<Cmpt, length>& dt)
 377 {
 378     DiagTensorN<Cmpt, length> res;
 379     VectorSpaceOps<DiagTensorN<Cmpt, length>::nComponents,0>::opSV
 380     (
 381         res,
 382         s,
 383         dt,
 384         divideOp3<Cmpt, scalar, Cmpt>()
 385     );
 386
 387     return res;
 388 }
 389
 390
 391 //- Inner Product of a VectorN by an inverse diagonalTensor
 392 template <class Cmpt, int length>
 393 inline VectorN<Cmpt, length>
 394 operator/(const VectorN<Cmpt, length>& v, const DiagTensorN<Cmpt, length>& dt)
 395 {
 396     VectorN<Cmpt, length> res(v);
 397     VectorSpaceOps<DiagTensorN<Cmpt, length>::nComponents,0>::eqOp
 398     (
 399         res,
 400         dt,
 401         divideEqOp<Cmpt>()
 402     );
 403
 404     return res;
 405 }
 406
 407
 408 //- Inner Product of a DiagTensorN and an inverse DiagTensorN
 409 template <class Cmpt, int length>
 410 inline DiagTensorN<Cmpt, length>
 411 operator/
 412 (
 413     const DiagTensorN<Cmpt, length>& dt1,
 414     const DiagTensorN<Cmpt, length>& dt2
 415 )
 416 {
 417     DiagTensorN<Cmpt, length> res;
 418     VectorSpaceOps<DiagTensorN<Cmpt, length>::nComponents,0>::op
 419     (
 420         res,
 421         dt1,
 422         dt2,
 423         divideOp<Cmpt>()
 424     );
 425
 426     return res;
 427 }
 428
 429
 430 //- Inner Product of a SphericalTensorN and an inverse DiagTensorN
 431 template <class Cmpt, int length>
 432 inline DiagTensorN<Cmpt, length>
 433 operator/
 434 (
 435     const SphericalTensorN<Cmpt, length>& st1,
 436     const DiagTensorN<Cmpt, length>& dt2
 437 )
 438 {
 439     const Cmpt& s = st1.v_[0];
 440     DiagTensorN<Cmpt, length> res;
 441     VectorSpaceOps<DiagTensorN<Cmpt, length>::nComponents,0>::opSV
 442     (
 443         res,
 444         s,
 445         dt2,
 446         divideOp<Cmpt>()
 447     );
 448
 449     return res;
 450 }
 451
 452
 453 //- Inner Product of a DiagTensorN and an inverse SphericalTensorN
 454 template <class Cmpt, int length>
 455 inline DiagTensorN<Cmpt, length>
 456 operator/
 457 (
 458     const DiagTensorN<Cmpt, length>& dt1,
 459     const SphericalTensorN<Cmpt, length>& st2
 460 )
 461 {
 462     const Cmpt& s = st2.v_[0];
 463     DiagTensorN<Cmpt, length> res;
 464     VectorSpaceOps<DiagTensorN<Cmpt, length>::nComponents,0>::opVS
 465     (
 466         res,
 467         dt1,
 468         s,
 469         divideOp<Cmpt>()
 470     );
 471
 472     return res;
 473 }
 474
 475
 476 //- Return the inverse of a diagonal tensor
 477 template <class Cmpt, int length>
 478 inline DiagTensorN<Cmpt, length> inv(const DiagTensorN<Cmpt, length>& dt)
 479 {
 480     DiagTensorN<Cmpt, length> res;
 481     VectorSpaceOps<DiagTensorN<Cmpt, length>::nComponents,0>::opSV
 482     (
 483         res,
 484         1.0,
 485         dt,
 486         divideOp<Cmpt>()
 487     );
 488
 489     return res;
 490 }
 491
 492
 493 //- Return tensor diagonal
 494 template <class Cmpt, int length>
 495 inline DiagTensorN<Cmpt, length> diag(const DiagTensorN<Cmpt, length>& dt)
 496 {
 497     return dt;
 498 }
 499
 500
 501 //- Return the component sum
 502 // template <class Cmpt, int length>
 503 // inline Cmpt sum(const DiagTensorN<Cmpt, length>& dt)
 504 // {
 505 //     Cmpt result=Cmpt::zero;
 506 //     for(register label i=0; i<DiagTensorN<Cmpt, length>::nComponents; i++)
 507 //     {
 508 //         result += dt[i];
 509 //     }
 510 //     return result;
 511 // }
 512
 513
 514 //- Transform the spherical tensor
 515 //- The components are assumed to be individual scalars
 516 //- i.e. transform has no effect
 517 template<class Cmpt, int length>
 518 inline DiagTensorN<Cmpt, length> transform
 519 (
 520     const tensor& tt,
 521     const DiagTensorN<Cmpt, length>& v
 522 )
 523 {
 524     return v;
 525 }
 526
 527
 528 // * * * * * * * * * * * * * * * Global Operators  * * * * * * * * * * * * * //
 529
 530 template<class Cmpt, int length>
 531 class outerProduct<DiagTensorN<Cmpt, length>, Cmpt>
 532 {
 533 public:
 534
 535     typedef DiagTensorN<Cmpt, length> type;
 536 };
 537
 538 template<class Cmpt, int length>
 539 class outerProduct<Cmpt, DiagTensorN<Cmpt, length> >
 540 {
 541 public:
 542
 543     typedef DiagTensorN<Cmpt, length> type;
 544 };
 545
 546
 547 template<class Cmpt, int length>
 548 class innerProduct<DiagTensorN<Cmpt, length>, DiagTensorN<Cmpt, length> >
 549 {
 550 public:
 551
 552     typedef DiagTensorN<Cmpt, length> type;
 553 };
 554
 555
 556 template<class Cmpt, int length>
 557 class innerProduct<SphericalTensorN<Cmpt, length>, DiagTensorN<Cmpt, length> >
 558 {
 559 public:
 560
 561     typedef DiagTensorN<Cmpt, length> type;
 562 };
 563
 564
 565 template<class Cmpt, int length>
 566 class innerProduct<DiagTensorN<Cmpt, length>, SphericalTensorN<Cmpt, length> >
 567 {
 568 public:
 569
 570     typedef DiagTensorN<Cmpt, length> type;
 571 };
 572
 573
 574 template<class Cmpt, int length>
 575 class innerProduct<VectorN<Cmpt, length>, DiagTensorN<Cmpt, length> >
 576 {
 577 public:
 578
 579     typedef VectorN<Cmpt, length> type;
 580 };
 581
 582
 583 template<class Cmpt, int length>
 584 class innerProduct<DiagTensorN<Cmpt, length>, VectorN<Cmpt, length> >
 585 {
 586 public:
 587
 588     typedef VectorN<Cmpt, length> type;
 589 };
 590
 591
 592 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 593
 594 } // End namespace Foam
 595
 596 // ************************************************************************* //