src/foam/primitives/VectorN/DiagTensorNI.H

   1 /*---------------------------------------------------------------------------*\
   2   =========                 |
   3   \\      /  F ield         | foam-extend: Open Source CFD
   4    \\    /   O peration     |
   5     \\  /    A nd           | For copyright notice see file Copyright
   6      \\/     M anipulation  |
   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 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
  44
  45 // Construct null
  46 template <class Cmpt, int length>
  47 inline DiagTensorN<Cmpt, length>::DiagTensorN()
  48 {}
  49
  50
  51 // Construct given VectorSpace
  52 template <class Cmpt, int length>
  53 inline DiagTensorN<Cmpt, length>::DiagTensorN
  54 (
  55     const VectorSpace<DiagTensorN<Cmpt, length>, Cmpt, length>& vs
  56 )
  57 :
  58     VectorSpace<DiagTensorN<Cmpt, length>, Cmpt, length>(vs)
  59 {}
  60
  61
  62 //- Construct from component
  63 template <class Cmpt, int length>
  64 inline DiagTensorN<Cmpt, length>::DiagTensorN(const Cmpt& tx)
  65 {
  66     VectorSpaceOps<DiagTensorN<Cmpt, length>::nComponents,0>::eqOpS(*this, tx, eqOp<Cmpt>());
  67 }
  68
  69
  70 // Construct from Istream
  71 template <class Cmpt, int length>
  72 inline DiagTensorN<Cmpt, length>::DiagTensorN(Istream& is)
  73 :
  74     VectorSpace<DiagTensorN<Cmpt, length>, Cmpt, length>(is)
  75 {}
  76
  77
  78 // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
  79
  80 //- Return diagonal tensor diagonal
  81 template <class Cmpt, int length>
  82 inline DiagTensorN<Cmpt, length> DiagTensorN<Cmpt, length>::diag() const
  83 {
  84     return *this;
  85 }
  86
  87 //- Return diagonal tensor transpose
  88 template <class Cmpt, int length>
  89 inline DiagTensorN<Cmpt, length> DiagTensorN<Cmpt, length>::T() const
  90 {
  91     return *this;
  92 }
  93
  94
  95 //- Assign to a SphericalTensorN
  96 template <class Cmpt, int length>
  97 inline void DiagTensorN<Cmpt, length>::operator=(const SphericalTensorN<Cmpt, length>& st)
  98 {
  99     const Cmpt& s = st.v_[0];
 100     VectorSpaceOps<DiagTensorN<Cmpt, length>::nComponents,0>::eqOpS(*this, s, eqOp<Cmpt>());
 101 }
 102
 103 // * * * * * * * * * * * * * * * Global Operators  * * * * * * * * * * * * * //
 104
 105 //- Addition of DiagTensorN and DiagTensorN
 106 template <class Cmpt, int length>
 107 inline DiagTensorN<Cmpt,length>
 108 operator+(const DiagTensorN<Cmpt,length>& dt1, const DiagTensorN<Cmpt,length>& dt2)
 109 {
 110     DiagTensorN<Cmpt, length> res;
 111     VectorSpaceOps<DiagTensorN<Cmpt,length>::nComponents,0>::op(res, dt1, dt2, plusOp<Cmpt>());
 112     return res;
 113 }
 114
 115
 116 //- Addition of DiagTensorN and SphericalTensorN
 117 template <class Cmpt, int length>
 118 inline DiagTensorN<Cmpt,length>
 119 operator+(const DiagTensorN<Cmpt,length>& dt1, const SphericalTensorN<Cmpt,length>& st2)
 120 {
 121     const Cmpt& s = st2.v_[0];
 122     DiagTensorN<Cmpt, length> res;
 123     VectorSpaceOps<DiagTensorN<Cmpt,length>::nComponents,0>::opVS(res, dt1, s, plusOp<Cmpt>());
 124     return res;
 125 }
 126
 127
 128 //- Addition of SphericalTensorN and DiagTensorN
 129 template <class Cmpt, int length>
 130 inline DiagTensorN<Cmpt,length>
 131 operator+(const SphericalTensorN<Cmpt,length>& st1, const DiagTensorN<Cmpt,length>& dt2)
 132 {
 133     const Cmpt& s = st1.v_[0];
 134     DiagTensorN<Cmpt, length> res;
 135     VectorSpaceOps<DiagTensorN<Cmpt,length>::nComponents,0>::opSV(res, s, dt2, plusOp<Cmpt>());
 136     return res;
 137 }
 138
 139
 140 //- Subtraction of DiagTensorN and DiagTensorN
 141 template <class Cmpt, int length>
 142 inline DiagTensorN<Cmpt,length>
 143 operator-(const DiagTensorN<Cmpt,length>& dt1, const DiagTensorN<Cmpt,length>& dt2)
 144 {
 145     DiagTensorN<Cmpt, length> res;
 146     VectorSpaceOps<DiagTensorN<Cmpt,length>::nComponents,0>::op(res, dt1, dt2, minusOp<Cmpt>());
 147     return res;
 148 }
 149
 150
 151 //- Subtraction of DiagTensorN and SphericalTensorN
 152 template <class Cmpt, int length>
 153 inline DiagTensorN<Cmpt,length>
 154 operator-(const DiagTensorN<Cmpt,length>& dt1, const SphericalTensorN<Cmpt,length>& st2)
 155 {
 156     const Cmpt& s = st2.v_[0];
 157     DiagTensorN<Cmpt, length> res;
 158     VectorSpaceOps<DiagTensorN<Cmpt,length>::nComponents,0>::opVS(res, dt1, s, minusOp<Cmpt>());
 159     return res;
 160 }
 161
 162
 163 //- Subtraction of SphericalTensorN and DiagTensorN
 164 template <class Cmpt, int length>
 165 inline DiagTensorN<Cmpt,length>
 166 operator-(const SphericalTensorN<Cmpt,length>& st1, const DiagTensorN<Cmpt,length>& dt2)
 167 {
 168     const Cmpt& s = st1.v_[0];
 169     DiagTensorN<Cmpt, length> res;
 170     VectorSpaceOps<DiagTensorN<Cmpt,length>::nComponents,0>::opSV(res, s, dt2, minusOp<Cmpt>());
 171     return res;
 172 }
 173
 174
 175 //- Inner-product between a diagonal tensor and a diagonal tensor
 176 template <class Cmpt, int length>
 177 inline typename
 178 innerProduct<DiagTensorN<Cmpt, length>, DiagTensorN<Cmpt, length> >::type
 179 operator&(const DiagTensorN<Cmpt, length>& dt1, const DiagTensorN<Cmpt, length>& dt2)
 180 {
 181     DiagTensorN<Cmpt, length> res;
 182     VectorSpaceOps<VectorN<Cmpt, length>::nComponents,0>::op(res, dt1, dt2, multiplyOp<Cmpt>());
 183     return res;
 184 }
 185
 186
 187 //- Inner-product between spherical tensor and diagonal tensor
 188 template <class Cmpt, int length>
 189 inline typename
 190 innerProduct<SphericalTensorN<Cmpt, length>, DiagTensorN<Cmpt, length> >::type
 191 operator&(const SphericalTensorN<Cmpt, length>& st1, const DiagTensorN<Cmpt, length>& dt2)
 192 {
 193     const Cmpt& s = st1.v_[0];
 194     DiagTensorN<Cmpt, length> res;
 195     VectorSpaceOps<VectorN<Cmpt, length>::nComponents,0>::opSV(res, s, dt2, multiplyOp<Cmpt>());
 196     return res;
 197 }
 198
 199
 200 //- Inner-product between diagonal tensor and spherical tensor
 201 template <class Cmpt, int length>
 202 inline typename
 203 innerProduct<DiagTensorN<Cmpt, length>, SphericalTensorN<Cmpt, length> >::type
 204 operator&(const DiagTensorN<Cmpt, length>& dt1, const SphericalTensorN<Cmpt, length>& st2)
 205 {
 206     const Cmpt& s = st2.v_[0];
 207     DiagTensorN<Cmpt, length> res;
 208     VectorSpaceOps<VectorN<Cmpt, length>::nComponents,0>::opVS(res, dt1, s, multiplyOp<Cmpt>());
 209     return res;
 210 }
 211
 212
 213 //- Inner-product between a diagonal tensor and a vector
 214 template <class Cmpt, int length>
 215 inline typename
 216 innerProduct<DiagTensorN<Cmpt, length>, VectorN<Cmpt, length> >::type
 217 operator&(const DiagTensorN<Cmpt, length>& dt, const VectorN<Cmpt, length>& v)
 218 {
 219     VectorN<Cmpt, length> res;
 220     VectorSpaceOps<VectorN<Cmpt, length>::nComponents,0>::opVV(res, dt, v, multiplyOp<Cmpt>());
 221     return res;
 222 }
 223
 224
 225
 226 //- Inner-product between a vector and a tensor
 227 template <class Cmpt, int length>
 228 inline typename
 229 innerProduct<VectorN<Cmpt, length>, DiagTensorN<Cmpt, length> >::type
 230 operator&(const VectorN<Cmpt, length>& v, const DiagTensorN<Cmpt, length>& dt)
 231 {
 232     VectorN<Cmpt, length> res;
 233     VectorSpaceOps<VectorN<Cmpt, length>::nComponents,0>::opVV(res, v, dt, multiplyOp<Cmpt>());
 234     return res;
 235 }
 236
 237
 238 //- Division of a scalar by a diagonalTensor
 239 template <class Cmpt, int length>
 240 inline DiagTensorN<Cmpt, length>
 241 operator/(const scalar s, const DiagTensorN<Cmpt, length>& dt)
 242 {
 243     DiagTensorN<Cmpt, length> res;
 244     VectorSpaceOps<DiagTensorN<Cmpt, length>::nComponents,0>::opSV(res, s, dt, divideOp3<Cmpt, scalar, Cmpt>());
 245     return res;
 246 }
 247
 248
 249 //- Inner Product of a VectorN by an inverse diagonalTensor
 250 template <class Cmpt, int length>
 251 inline VectorN<Cmpt,length>
 252 operator/(const VectorN<Cmpt,length>& v, const DiagTensorN<Cmpt,length>& dt)
 253 {
 254     VectorN<Cmpt, length> res(v);
 255     VectorSpaceOps<DiagTensorN<Cmpt, length>::nComponents,0>::eqOp(res, dt, divideEqOp<Cmpt>());
 256     return res;
 257 }
 258
 259
 260 //- Inner Product of a DiagTensorN and an inverse DiagTensorN
 261 template <class Cmpt, int length>
 262 inline DiagTensorN<Cmpt,length>
 263 operator/(const DiagTensorN<Cmpt,length>& dt1, const DiagTensorN<Cmpt,length>& dt2)
 264 {
 265     DiagTensorN<Cmpt, length> res;
 266     VectorSpaceOps<DiagTensorN<Cmpt, length>::nComponents,0>::op(res, dt1, dt2, divideOp<Cmpt>());
 267     return res;
 268 }
 269
 270
 271 //- Inner Product of a SphericalTensorN and an inverse DiagTensorN
 272 template <class Cmpt, int length>
 273 inline DiagTensorN<Cmpt,length>
 274 operator/(const SphericalTensorN<Cmpt,length>& st1, const DiagTensorN<Cmpt,length>& dt2)
 275 {
 276     const Cmpt& s = st1.v_[0];
 277     DiagTensorN<Cmpt, length> res;
 278     VectorSpaceOps<DiagTensorN<Cmpt, length>::nComponents,0>::opSV(res, s, dt2, divideOp<Cmpt>());
 279     return res;
 280 }
 281
 282
 283 //- Inner Product of a DiagTensorN and an inverse SphericalTensorN
 284 template <class Cmpt, int length>
 285 inline DiagTensorN<Cmpt,length>
 286 operator/(const DiagTensorN<Cmpt,length>& dt1, const SphericalTensorN<Cmpt,length>& st2)
 287 {
 288     const Cmpt& s = st2.v_[0];
 289     DiagTensorN<Cmpt, length> res;
 290     VectorSpaceOps<DiagTensorN<Cmpt, length>::nComponents,0>::opVS(res, dt1, s, divideOp<Cmpt>());
 291     return res;
 292 }
 293
 294
 295 //- Return the inverse of a diagonal tensor
 296 template <class Cmpt, int length>
 297 inline DiagTensorN<Cmpt, length> inv(const DiagTensorN<Cmpt, length>& dt)
 298 {
 299     DiagTensorN<Cmpt, length> res;
 300     VectorSpaceOps<DiagTensorN<Cmpt, length>::nComponents,0>::opSV(res, 1.0, dt, divideOp<Cmpt>());
 301     return res;
 302 }
 303
 304
 305 //- Return tensor diagonal
 306 template <class Cmpt, int length>
 307 inline DiagTensorN<Cmpt, length> diag(const DiagTensorN<Cmpt, length>& dt)
 308 {
 309     return dt;
 310 }
 311
 312
 313 //- Return the component sum
 314 // template <class Cmpt, int length>
 315 // inline Cmpt sum(const DiagTensorN<Cmpt, length>& dt)
 316 // {
 317 //     Cmpt result=Cmpt::zero;
 318 //     for(register label i=0; i<DiagTensorN<Cmpt, length>::nComponents; i++)
 319 //     {
 320 //         result += dt[i];
 321 //     }
 322 //     return result;
 323 // }
 324
 325
 326 //- Transform the spherical tensor
 327 //- The components are assumed to be individual scalars
 328 //- i.e. transform has no effect
 329 template<class Cmpt, int length>
 330 inline DiagTensorN<Cmpt, length> transform
 331 (
 332     const tensor& tt,
 333     const DiagTensorN<Cmpt, length>& v
 334 )
 335 {
 336     return v;
 337 }
 338
 339
 340 // * * * * * * * * * * * * * * * Global Operators  * * * * * * * * * * * * * //
 341
 342 template<class Cmpt, int length>
 343 class outerProduct<DiagTensorN<Cmpt, length>, Cmpt>
 344 {
 345 public:
 346
 347     typedef DiagTensorN<Cmpt, length> type;
 348 };
 349
 350 template<class Cmpt, int length>
 351 class outerProduct<Cmpt, DiagTensorN<Cmpt, length> >
 352 {
 353 public:
 354
 355     typedef DiagTensorN<Cmpt, length> type;
 356 };
 357
 358
 359 template<class Cmpt, int length>
 360 class innerProduct<DiagTensorN<Cmpt, length>, DiagTensorN<Cmpt, length> >
 361 {
 362 public:
 363
 364     typedef DiagTensorN<Cmpt, length> type;
 365 };
 366
 367
 368 template<class Cmpt, int length>
 369 class innerProduct<SphericalTensorN<Cmpt, length>, DiagTensorN<Cmpt, length> >
 370 {
 371 public:
 372
 373     typedef DiagTensorN<Cmpt, length> type;
 374 };
 375
 376
 377 template<class Cmpt, int length>
 378 class innerProduct<DiagTensorN<Cmpt, length>, SphericalTensorN<Cmpt, length> >
 379 {
 380 public:
 381
 382     typedef DiagTensorN<Cmpt, length> type;
 383 };
 384
 385
 386 template<class Cmpt, int length>
 387 class innerProduct<VectorN<Cmpt, length>, DiagTensorN<Cmpt, length> >
 388 {
 389 public:
 390
 391     typedef VectorN<Cmpt, length> type;
 392 };
 393
 394
 395 template<class Cmpt, int length>
 396 class innerProduct<DiagTensorN<Cmpt, length>, VectorN<Cmpt, length> >
 397 {
 398 public:
 399
 400     typedef VectorN<Cmpt, length> type;
 401 };
 402
 403
 404 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 405
 406 } // End namespace Foam
 407
 408 // ************************************************************************* //