src/VectorN/OpenFOAM/primitives/SphericalTensorNI.H

   1 /*---------------------------------------------------------------------------*\
   2   =========                 |
   3   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
   4    \\    /   O peration     |
   5     \\  /    A nd           | Copyright held by original author
   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 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
  28
  29 namespace Foam
  30 {
  31
  32 // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
  33
  34 template <class Cmpt, int length>
  35 const char* const SphericalTensorN<Cmpt, length>::typeName =
  36     ("sphericalTensor" + name(length)).c_str();
  37
  38 template <class Cmpt, int length>
  39 const SphericalTensorN<Cmpt, length> SphericalTensorN<Cmpt, length>::zero(0);
  40
  41 template <class Cmpt, int length>
  42 const SphericalTensorN<Cmpt, length> SphericalTensorN<Cmpt, length>::one(1);
  43
  44 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
  45
  46 // Construct null
  47 template <class Cmpt, int length>
  48 inline SphericalTensorN<Cmpt, length>::SphericalTensorN()
  49 {}
  50
  51
  52 // Construct given VectorSpace
  53 template <class Cmpt, int length>
  54 inline SphericalTensorN<Cmpt, length>::SphericalTensorN
  55 (
  56     const VectorSpace<SphericalTensorN<Cmpt, length>, Cmpt, 1>& vs
  57 )
  58 :
  59     VectorSpace<SphericalTensorN<Cmpt, length>, Cmpt, 1>(vs)
  60 {}
  61
  62
  63 //- Construct from component
  64 template <class Cmpt, int length>
  65 inline SphericalTensorN<Cmpt, length>::SphericalTensorN(const Cmpt& tx)
  66 {
  67     this->v_[0] = tx;
  68 }
  69
  70
  71 // Construct from Istream
  72 template <class Cmpt, int length>
  73 inline SphericalTensorN<Cmpt, length>::SphericalTensorN(Istream& is)
  74 :
  75     VectorSpace<SphericalTensorN<Cmpt, length>, Cmpt, 1>(is)
  76 {}
  77
  78
  79 // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
  80
  81 //- Return diagonal tensor diagonal
  82 template <class Cmpt, int length>
  83 inline SphericalTensorN<Cmpt, length> SphericalTensorN<Cmpt, length>::diag() const
  84 {
  85     return *this;
  86 }
  87
  88 //- Return spherical tensor transpose
  89 template <class Cmpt, int length>
  90 inline SphericalTensorN<Cmpt, length> SphericalTensorN<Cmpt, length>::T() const
  91 {
  92     return *this;
  93 }
  94
  95
  96 //- Transform the spherical tensor
  97 //- The components are assumed to be individual scalars
  98 //- i.e. transform has no effect
  99 template<class Cmpt, int length>
 100 inline SphericalTensorN<Cmpt, length> transform
 101 (
 102     const tensor& tt,
 103     const SphericalTensorN<Cmpt, length>& v
 104 )
 105 {
 106     return v;
 107 }
 108
 109
 110 // * * * * * * * * * * * * * * * Global Operators  * * * * * * * * * * * * * //
 111
 112
 113 //- Addition of SphericalTensorN and SphericalTensorN
 114 template <class Cmpt, int length>
 115 inline SphericalTensorN<Cmpt,length>
 116 operator+(const SphericalTensorN<Cmpt,length>& st1, const SphericalTensorN<Cmpt,length>& st2)
 117 {
 118     return SphericalTensorN<Cmpt, length>(st1.v_[0] + st2.v_[0]);
 119 }
 120
 121
 122 //- Subtraction of SphericalTensorN and SphericalTensorN
 123 template <class Cmpt, int length>
 124 inline SphericalTensorN<Cmpt,length>
 125 operator-(const SphericalTensorN<Cmpt,length>& st1, const SphericalTensorN<Cmpt,length>& st2)
 126 {
 127     return SphericalTensorN<Cmpt, length>(st1.v_[0] - st2.v_[0]);
 128 }
 129
 130
 131 //- Inner-product between spherical tensor and spherical tensor
 132 template <class Cmpt, int length>
 133 inline typename
 134 innerProduct<SphericalTensorN<Cmpt, length>, SphericalTensorN<Cmpt, length> >::type
 135 operator&(const SphericalTensorN<Cmpt, length>& st1, const SphericalTensorN<Cmpt, length>& st2)
 136 {
 137     return SphericalTensorN<Cmpt, length>(st1.v_[0]*st2.v_[0]);
 138 }
 139
 140
 141 //- Inner-product between a spherical tensor and a vector
 142 template <class Cmpt, int length>
 143 inline typename
 144 innerProduct<SphericalTensorN<Cmpt, length>, VectorN<Cmpt, length> >::type
 145 operator&(const SphericalTensorN<Cmpt, length>& st, const VectorN<Cmpt, length>& v)
 146 {
 147     const Cmpt& s = st.v_[0];
 148     VectorN<Cmpt, length> res;
 149     VectorSpaceOps<VectorN<Cmpt, length>::nComponents,0>::opSV(res, s, v, multiplyOp<Cmpt>());
 150     return res;
 151 }
 152
 153
 154 //- Inner-product between a vector and a spherical tensor
 155 template <class Cmpt, int length>
 156 inline typename
 157 innerProduct<VectorN<Cmpt, length>, SphericalTensorN<Cmpt, length> >::type
 158 operator&(const VectorN<Cmpt, length>& v, const SphericalTensorN<Cmpt, length>& st)
 159 {
 160     const Cmpt& s = st.v_[0];
 161     VectorN<Cmpt, length> res;
 162     VectorSpaceOps<VectorN<Cmpt, length>::nComponents,0>::opVS(res, v, s, multiplyOp<Cmpt>());
 163     return res;
 164 }
 165
 166
 167 //- Product of a scalar and a spherical tensor
 168 template <class Cmpt, int length>
 169 inline SphericalTensorN<Cmpt, length>
 170 operator*(const scalar s, const SphericalTensorN<Cmpt, length>& st)
 171 {
 172     return SphericalTensorN<Cmpt, length>(s*st.v_[0]);
 173 }
 174
 175
 176 //- Division of a scalar by a spherical tensor
 177 template <class Cmpt, int length>
 178 inline SphericalTensorN<Cmpt, length>
 179 operator/(const scalar s, const SphericalTensorN<Cmpt, length>& st)
 180 {
 181     return SphericalTensorN<Cmpt, length>(s/st.v_[0]);
 182 }
 183
 184
 185 //- Inner Product of a VectorN by an inverse SphericalTensorN
 186 template <class Cmpt, int length>
 187 inline VectorN<Cmpt,length>
 188 operator/(const VectorN<Cmpt,length>& v, const SphericalTensorN<Cmpt,length>& st)
 189 {
 190     return v/st.v_[0];
 191 }
 192
 193
 194 //- Inner Product of a SphericalTensorN and an inverse SphericalTensorN
 195 template <class Cmpt, int length>
 196 inline SphericalTensorN<Cmpt,length>
 197 operator/(const SphericalTensorN<Cmpt,length>& st1, const SphericalTensorN<Cmpt,length>& st2)
 198 {
 199     return SphericalTensorN<Cmpt, length>(st1.v_[0]/st2.v_[0]);
 200 }
 201
 202
 203 //- Return the inverse of a spherical tensor
 204 template <class Cmpt, int length>
 205 inline SphericalTensorN<Cmpt, length> inv(const SphericalTensorN<Cmpt, length>& st)
 206 {
 207     return SphericalTensorN<Cmpt, length>(pTraits<Cmpt>::one/st.v_[0]);
 208 }
 209
 210
 211 //- Return tensor diagonal
 212 template <class Cmpt, int length>
 213 inline SphericalTensorN<Cmpt, length> diag(const SphericalTensorN<Cmpt, length>& st)
 214 {
 215     return st;
 216 }
 217
 218 //- Return the component sum
 219 template <class Cmpt, int length>
 220 inline Cmpt sum(const SphericalTensorN<Cmpt, length>& st)
 221 {
 222     return SphericalTensorN<Cmpt, length>::rowLength*st.v_[0];
 223 }
 224
 225
 226 // * * * * * * * * * * * * * * * Global Operators  * * * * * * * * * * * * * //
 227
 228 template<class Cmpt, int length>
 229 class outerProduct<Cmpt, SphericalTensorN<Cmpt, length> >
 230 {
 231 public:
 232
 233     typedef SphericalTensorN<Cmpt, length> type;
 234 };
 235
 236 template<class Cmpt, int length>
 237 class outerProduct<SphericalTensorN<Cmpt, length>, Cmpt>
 238 {
 239 public:
 240
 241     typedef SphericalTensorN<Cmpt, length> type;
 242 };
 243
 244
 245 template<class Cmpt, int length>
 246 class innerProduct<SphericalTensorN<Cmpt, length>, VectorN<Cmpt, length> >
 247 {
 248 public:
 249
 250     typedef VectorN<Cmpt, length> type;
 251 };
 252
 253 template<class Cmpt, int length>
 254 class innerProduct<VectorN<Cmpt, length>, SphericalTensorN<Cmpt, length> >
 255 {
 256 public:
 257
 258     typedef VectorN<Cmpt, length> type;
 259 };
 260
 261 template<class Cmpt, int length>
 262 class innerProduct<SphericalTensorN<Cmpt, length>, SphericalTensorN<Cmpt, length> >
 263 {
 264 public:
 265
 266     typedef SphericalTensorN<Cmpt, length> type;
 267 };
 268
 269
 270 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 271
 272 } // End namespace Foam
 273
 274 // ************************************************************************* //