src/VectorN/OpenFOAM/expandContract/ExpandTensorNI.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 Class
  26     ExpandTensorN
  27
  28 Description
  29
  30 Author
  31
  32 \*---------------------------------------------------------------------------*/
  33
  34 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
  35
  36 namespace Foam
  37 {
  38
  39 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
  40
  41 //- Return the Average of a vector of as a scalar
  42 template <class Cmpt, int length>
  43 inline void contractScalar(Cmpt& result, const VectorN<Cmpt, length>& t)
  44 {
  45     result = pTraits<Cmpt>::zero;
  46
  47     for (int i = 0; i < TensorN<Cmpt, length>::rowLength; i++)
  48     {
  49         result += t[i];
  50     }
  51
  52 //- Modified 2009/11/3 by I. Clifford
  53     result *= 1.0/VectorN<Cmpt, length>::nComponents;
  54 }
  55
  56
  57 //- Return the Average of a vector of as a scalar
  58 template <class Cmpt, int length>
  59 inline Cmpt contractScalar(const VectorN<Cmpt, length>& t)
  60 {
  61     Cmpt result;
  62     contractScalar(result, t);
  63     return result;
  64 }
  65
  66
  67 //- Return the diagonal of a TensorN as a scalar
  68 template <class Cmpt, int length>
  69 inline void contractScalar(Cmpt& result, const TensorN<Cmpt, length>& t)
  70 {
  71     result = pTraits<Cmpt>::zero;
  72
  73     int j=0;
  74     for (int i = 0; i < TensorN<Cmpt, length>::rowLength; i++)
  75     {
  76         result += t[j];
  77         j += TensorN<Cmpt, length>::rowLength+1;
  78     }
  79
  80 //- Modified 2009/11/3 by I. Clifford
  81     result *= 1.0/TensorN<Cmpt, length>::rowLength;
  82 }
  83
  84
  85 //- Return the diagonal of a TensorN as a scalar
  86 template <class Cmpt, int length>
  87 inline Cmpt contractScalar(const TensorN<Cmpt, length>& t)
  88 {
  89     Cmpt result;
  90     contractScalar(result, t);
  91     return result;
  92 }
  93
  94
  95 //- Return the diagonal of a DiagTensorN as a scalar
  96 template <class Cmpt, int length>
  97 inline void contractScalar(Cmpt& result, const DiagTensorN<Cmpt, length>& t)
  98 {
  99     result = pTraits<Cmpt>::zero;
 100
 101     for (int i = 0; i < DiagTensorN<Cmpt, length>::rowLength; i++)
 102     {
 103         result += t[i];
 104     }
 105
 106     result *= 1.0/TensorN<Cmpt, length>::rowLength;
 107 }
 108
 109
 110 //- Return the diagonal of a DiagTensorN as a scalar
 111 template <class Cmpt, int length>
 112 inline Cmpt contractScalar(const DiagTensorN<Cmpt, length>& t)
 113 {
 114     Cmpt result;
 115     contractScalar(result, t);
 116     return result;
 117 }
 118
 119
 120 //- Return the diagonal of a SphericalTensorN as a scalar
 121 template <class Cmpt, int length>
 122 inline void contractScalar(Cmpt& result, const SphericalTensorN<Cmpt, length>& t)
 123 {
 124     result = t[0];
 125 }
 126
 127
 128 //- Return the diagonal of a SphericalTensorN as a scalar
 129 template <class Cmpt, int length>
 130 inline Cmpt contractScalar(const SphericalTensorN<Cmpt, length>& t)
 131 {
 132     Cmpt result;
 133     contractScalar(result, t);
 134     return result;
 135 }
 136
 137
 138 //- Return the diagonal of a TensorN as a vector
 139 template <class Cmpt, int length>
 140 inline void contractLinear
 141 (
 142     VectorN<Cmpt, length>& result,
 143     const TensorN<Cmpt, length>& t
 144 )
 145 {
 146     int j=0;
 147     for (int i = 0; i < TensorN<Cmpt, length>::rowLength; i++)
 148     {
 149         result[i] = t[j];
 150         j += TensorN<Cmpt, length>::rowLength+1;
 151     }
 152 }
 153
 154
 155 //- Return the diagonal of a TensorN as a vector
 156 template <class Cmpt, int length>
 157 inline VectorN<Cmpt, length> contractLinear(const TensorN<Cmpt, length>& t)
 158 {
 159     VectorN<Cmpt, length> result;
 160     contractLinear(result, t);
 161     return result;
 162 }
 163
 164
 165 //- Return the diagonal of a DiagTensorN as a vector
 166 template <class Cmpt, int length>
 167 inline void contractLinear
 168 (
 169     VectorN<Cmpt, length>& result,
 170     const DiagTensorN<Cmpt, length>& t
 171 )
 172 {
 173     for (int i = 0; i < DiagTensorN<Cmpt, length>::rowLength; i++)
 174     {
 175         result[i] = t[i];
 176     }
 177 }
 178
 179
 180 //- Return the diagonal of a DiagTensorN as a vector
 181 template <class Cmpt, int length>
 182 inline VectorN<Cmpt, length> contractLinear(const DiagTensorN<Cmpt, length>& t)
 183 {
 184     VectorN<Cmpt, length> result;
 185     contractLinear(result, t);
 186     return result;
 187 }
 188
 189
 190 //- Return the diagonal of a SphericalTensorN as a vector
 191 template <class Cmpt, int length>
 192 inline void contractLinear
 193 (
 194     VectorN<Cmpt, length>& result,
 195     const SphericalTensorN<Cmpt, length>& t
 196 )
 197 {
 198     for (int i = 0; i < SphericalTensorN<Cmpt, length>::rowLength; i++)
 199     {
 200         result[i] = t[0];
 201     }
 202 }
 203
 204
 205 //- Return the diagonal of a SphericalTensorN as a vector
 206 template <class Cmpt, int length>
 207 inline VectorN<Cmpt, length> contractLinear
 208 (
 209     const SphericalTensorN<Cmpt, length>& t
 210 )
 211 {
 212     VectorN<Cmpt, length> result;
 213     contractLinear(result, t);
 214     return result;
 215 }
 216
 217
 218 //- Return the VectorN given a scalar
 219 template <class Cmpt, int length>
 220 inline void expandScalar(VectorN<Cmpt, length>& result, const Cmpt& v)
 221 {
 222     for (int i = 0; i < VectorN<Cmpt, length>::nComponents; i++)
 223     {
 224         result[i] = v;
 225     }
 226 }
 227
 228
 229 //- Return the TensorN given a scalar
 230 template <class Cmpt, int length>
 231 inline void expandScalar(TensorN<Cmpt, length>& result, const Cmpt& v)
 232 {
 233     result = TensorN<Cmpt, length>::zero;
 234
 235     int j =0;
 236     for (int i = 0; i < TensorN<Cmpt, length>::rowLength; i++)
 237     {
 238         result[j] = v;
 239         j += TensorN<Cmpt, length>::rowLength+1;
 240     }
 241 }
 242
 243
 244 //- Return the DiagTensorN given a scalar
 245 template <class Cmpt, int length>
 246 inline void expandScalar(DiagTensorN<Cmpt, length>& result, const Cmpt& v)
 247 {
 248     for (int i = 0; i < DiagTensorN<Cmpt, length>::rowLength; i++)
 249     {
 250         result[i] = v;
 251     }
 252 }
 253
 254
 255 //- Return the SphericalTensorN given a scalar
 256 template <class Cmpt, int length>
 257 inline void expandScalar(SphericalTensorN<Cmpt, length>& result, const Cmpt& v)
 258 {
 259     result[0] = v;
 260 }
 261
 262
 263 //- Return the TensorN given a diagonal vectorN
 264 template <class Cmpt, int length>
 265 inline void expandLinear
 266 (
 267     TensorN<Cmpt, length>& result,
 268     const VectorN<Cmpt, length>& v
 269 )
 270 {
 271     result = TensorN<Cmpt, length>::zero;
 272
 273     int j=0;
 274     for (int i = 0; i < TensorN<Cmpt, length>::rowLength; i++)
 275     {
 276         result[j] = v[i];
 277         j += TensorN<Cmpt, length>::rowLength+1;
 278     }
 279 }
 280
 281 //- Return the DiagTensorN given a diagonal vectorN
 282 template <class Cmpt, int length>
 283 inline void expandLinear
 284 (
 285     DiagTensorN<Cmpt, length>& result,
 286     const VectorN<Cmpt, length>& v
 287 )
 288 {
 289     for (int i = 0; i < DiagTensorN<Cmpt, length>::rowLength; i++)
 290     {
 291         result[i] = v[i];
 292     }
 293 }
 294
 295
 296 //- Return the SphericalTensorN given a diagonal vectorN
 297 template <class Cmpt, int length>
 298 inline void expandLinear
 299 (
 300     SphericalTensorN<Cmpt, length>& result,
 301     const VectorN<Cmpt, length>& v
 302 )
 303 {
 304     result[0] = pTraits<Cmpt>::zero;
 305
 306     for (int i = 0; i < DiagTensorN<Cmpt, length>::rowLength; i++)
 307     {
 308         result[0] += v[i];
 309     }
 310
 311     result[0] *= 1.0/DiagTensorN<Cmpt, length>::rowLength;
 312 }
 313
 314
 315 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 316
 317 } // End namespace Foam
 318
 319 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 320
 321
 322 // ************************************************************************* //