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