src/foam/primitives/DiagTensor/DiagTensorTemplateI.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 #include "SphericalTensorTemplate.H"
  27
  28 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
  29
  30 namespace Foam
  31 {
  32
  33 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
  34
  35 // Construct null
  36 template <class Cmpt>
  37 inline DiagTensor<Cmpt>::DiagTensor()
  38 {}
  39
  40
  41 // Construct given VectorSpace
  42 template <class Cmpt>
  43 inline DiagTensor<Cmpt>::DiagTensor
  44 (
  45     const VectorSpace<DiagTensor<Cmpt>, Cmpt, 3>& vs
  46 )
  47 :
  48     VectorSpace<DiagTensor<Cmpt>, Cmpt, 3>(vs)
  49 {}
  50
  51
  52 // Construct given three Cmpts
  53 template <class Cmpt>
  54 inline DiagTensor<Cmpt>::DiagTensor
  55 (
  56     const Cmpt& vxx,
  57     const Cmpt& vyy,
  58     const Cmpt& vzz
  59 )
  60 {
  61     this->v_[XX] = vxx;
  62     this->v_[YY] = vyy;
  63     this->v_[ZZ] = vzz;
  64 }
  65
  66
  67 // Construct from Istream
  68 template <class Cmpt>
  69 inline DiagTensor<Cmpt>::DiagTensor(Istream& is)
  70 :
  71     VectorSpace<DiagTensor<Cmpt>, Cmpt, 3>(is)
  72 {}
  73
  74
  75 // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
  76
  77 template <class Cmpt>
  78 inline const Cmpt&  DiagTensor<Cmpt>::xx() const
  79 {
  80     return this->v_[XX];
  81 }
  82
  83 template <class Cmpt>
  84 inline const Cmpt&  DiagTensor<Cmpt>::yy() const
  85 {
  86     return this->v_[YY];
  87 }
  88
  89 template <class Cmpt>
  90 inline const Cmpt&  DiagTensor<Cmpt>::zz() const
  91 {
  92     return this->v_[ZZ];
  93 }
  94
  95
  96 template <class Cmpt>
  97 inline Cmpt& DiagTensor<Cmpt>::xx()
  98 {
  99     return this->v_[XX];
 100 }
 101
 102 template <class Cmpt>
 103 inline Cmpt& DiagTensor<Cmpt>::yy()
 104 {
 105     return this->v_[YY];
 106 }
 107
 108 template <class Cmpt>
 109 inline Cmpt& DiagTensor<Cmpt>::zz()
 110 {
 111     return this->v_[ZZ];
 112 }
 113
 114
 115 // * * * * * * * * * * * * * * * Global Operators  * * * * * * * * * * * * * //
 116
 117 template <class Cmpt>
 118 inline Tensor<Cmpt>
 119 operator+(const DiagTensor<Cmpt>& dt1, const Tensor<Cmpt>& t2)
 120 {
 121     return Tensor<Cmpt>
 122     (
 123         dt1.xx() + t2.xx(), t2.xy(),            t2.xz(),
 124         t2.yx(),            dt1.yy() + t2.yy(), t2.yz(),
 125         t2.zx(),            t2.zy(),            dt1.zz() + t2.zz()
 126     );
 127 }
 128
 129
 130 template <class Cmpt>
 131 inline Tensor<Cmpt>
 132 operator+(const Tensor<Cmpt>& t1, const DiagTensor<Cmpt>& dt2)
 133 {
 134     return Tensor<Cmpt>
 135     (
 136         t1.xx() + dt2.xx(), t1.xy(),            t1.xz(),
 137         t1.yx(),            t1.yy() + dt2.yy(), t1.yz(),
 138         t1.zx(),            t1.zy(),            t1.zz() + dt2.zz()
 139     );
 140 }
 141
 142
 143 template <class Cmpt>
 144 inline Tensor<Cmpt>
 145 operator-(const DiagTensor<Cmpt>& dt1, const Tensor<Cmpt>& t2)
 146 {
 147     return Tensor<Cmpt>
 148     (
 149         dt1.xx() - t2.xx(), -t2.xy(),            -t2.xz(),
 150        -t2.yx(),             dt1.yy() - t2.yy(), -t2.yz(),
 151        -t2.zx(),            -t2.zy(),             dt1.zz() - t2.zz()
 152     );
 153 }
 154
 155
 156 template <class Cmpt>
 157 inline Tensor<Cmpt>
 158 operator-(const Tensor<Cmpt>& t1, const DiagTensor<Cmpt>& dt2)
 159 {
 160     return Tensor<Cmpt>
 161     (
 162         t1.xx() - dt2.xx(), t1.xy(),            t1.xz(),
 163         t1.yx(),            t1.yy() - dt2.yy(), t1.yz(),
 164         t1.zx(),            t1.zy(),            t1.zz() - dt2.zz()
 165     );
 166 }
 167
 168
 169 //- Inner-product between two diagonal tensors
 170 template <class Cmpt>
 171 inline DiagTensor<Cmpt>
 172 operator&(const DiagTensor<Cmpt>& dt1, const DiagTensor<Cmpt>& dt2)
 173 {
 174     return DiagTensor<Cmpt>
 175     (
 176         dt1.xx()*dt2.xx(),
 177         dt1.yy()*dt2.yy(),
 178         dt1.zz()*dt2.zz()
 179     );
 180 }
 181
 182
 183 //- Inner-product between a diagonal tensor and a tensor
 184 template <class Cmpt>
 185 inline Tensor<Cmpt>
 186 operator&(const DiagTensor<Cmpt>& dt1, const Tensor<Cmpt>& t2)
 187 {
 188     return Tensor<Cmpt>
 189     (
 190         dt1.xx()*t2.xx(),
 191         dt1.xx()*t2.xy(),
 192         dt1.xx()*t2.xz(),
 193
 194                           dt1.yy()*t2.yx(),
 195                           dt1.yy()*t2.yy(),
 196                           dt1.yy()*t2.yz(),
 197
 198                                             dt1.zz()*t2.zx(),
 199                                             dt1.zz()*t2.zy(),
 200                                             dt1.zz()*t2.zz()
 201     );
 202 }
 203
 204
 205 //- Inner-product between a tensor and a diagonal tensor
 206 template <class Cmpt>
 207 inline Tensor<Cmpt>
 208 operator&(const Tensor<Cmpt>& t1, const DiagTensor<Cmpt>& dt2)
 209 {
 210     return Tensor<Cmpt>
 211     (
 212         t1.xx()*dt2.xx(),
 213                           t1.xy()*dt2.yy(),
 214                                             t1.xz()*dt2.zz(),
 215
 216         t1.yx()*dt2.xx(),
 217                           t1.yy()*dt2.yy(),
 218                                             t1.yz()*dt2.zz(),
 219
 220         t1.zx()*dt2.xx(),
 221                           t1.zy()*dt2.yy(),
 222                                             t1.zz()*dt2.zz()
 223     );
 224 }
 225
 226
 227 //- Inner-product between a diagonal tensor and a vector
 228 template <class Cmpt>
 229 inline Vector<Cmpt>
 230 operator&(const DiagTensor<Cmpt>& dt, const Vector<Cmpt>& v)
 231 {
 232     return Vector<Cmpt>
 233     (
 234         dt.xx()*v.x(),
 235                        dt.yy()*v.y(),
 236                                       dt.zz()*v.z()
 237     );
 238 }
 239
 240
 241 //- Inner-product between a vector and a diagonal tensor
 242 template <class Cmpt>
 243 inline Vector<Cmpt>
 244 operator&(const Vector<Cmpt>& v, const DiagTensor<Cmpt>& dt)
 245 {
 246     return Vector<Cmpt>
 247     (
 248         v.x()*dt.xx(),
 249                        v.y()*dt.yy(),
 250                                       v.z()*dt.zz()
 251     );
 252 }
 253
 254
 255 //- Division of a scalar by a diagonalTensor
 256 template <class Cmpt>
 257 inline DiagTensor<Cmpt>
 258 operator/(const scalar s, const DiagTensor<Cmpt>& dt)
 259 {
 260     return DiagTensor<Cmpt>(s/dt.xx(), s/dt.yy(), s/dt.zz());
 261 }
 262
 263
 264 //- Division of a vector by a diagonalTensor
 265 template <class Cmpt>
 266 inline Vector<Cmpt>
 267 operator/(const Vector<Cmpt> v, const DiagTensor<Cmpt>& dt)
 268 {
 269     return Vector<Cmpt>(v.x()/dt.xx(), v.y()/dt.yy(), v.z()/dt.zz());
 270 }
 271
 272
 273 //- Return the trace of a diagonal tensor
 274 template <class Cmpt>
 275 inline Cmpt tr(const DiagTensor<Cmpt>& dt)
 276 {
 277     return dt.xx() + dt.yy() + dt.zz();
 278 }
 279
 280
 281 //- Return the spherical part of a diagonal tensor
 282 template <class Cmpt>
 283 inline SphericalTensor<Cmpt> sph(const DiagTensor<Cmpt>& dt)
 284 {
 285     return 0.5*tr(dt);
 286 }
 287
 288
 289 //- Return the determinant of a diagonal tensor
 290 template <class Cmpt>
 291 inline Cmpt det(const DiagTensor<Cmpt>& t)
 292 {
 293     return t.xx()*t.yy()*t.zz();
 294 }
 295
 296
 297 //- Return the inverse of a symmetric tensor
 298 template <class Cmpt>
 299 inline DiagTensor<Cmpt> inv(const DiagTensor<Cmpt>& dt)
 300 {
 301     return DiagTensor<Cmpt>(1.0/dt.xx(), 1.0/dt.yy(), 1.0/dt.zz());
 302 }
 303
 304
 305 //- Return the diagonal of a tensor as a diagonal tensor
 306 template <class Cmpt>
 307 inline DiagTensor<Cmpt> diag(const Tensor<Cmpt>& t)
 308 {
 309     return DiagTensor<Cmpt>(t.xx(), t.yy(), t.zz());
 310 }
 311
 312
 313 template<class Cmpt>
 314 class innerProduct<DiagTensor<Cmpt>, DiagTensor<Cmpt> >
 315 {
 316 public:
 317
 318     typedef DiagTensor<Cmpt> type;
 319 };
 320
 321 template<class Cmpt>
 322 class outerProduct<DiagTensor<Cmpt>, Cmpt>
 323 {
 324 public:
 325
 326     typedef DiagTensor<Cmpt> type;
 327 };
 328
 329 template<class Cmpt>
 330 class outerProduct<Cmpt, DiagTensor<Cmpt> >
 331 {
 332 public:
 333
 334     typedef DiagTensor<Cmpt> type;
 335 };
 336
 337
 338 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 339
 340 } // End namespace Foam
 341
 342 // ************************************************************************* //