src/VectorN/OpenFOAM/primitives/VectorNI.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 template<class Cmpt, int length>
  33 class TensorN;
  34
  35 // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
  36
  37 template <class Cmpt, int length>
  38 const char* const VectorN<Cmpt, length>::typeName =
  39     ("vector" + name(length)).c_str();
  40
  41 template <class Cmpt, int length>
  42 const VectorN<Cmpt, length> VectorN<Cmpt, length>::zero(0);
  43
  44 template <class Cmpt, int length>
  45 const VectorN<Cmpt, length> VectorN<Cmpt, length>::one(1);
  46
  47
  48 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
  49
  50 // Construct null
  51 template <class Cmpt, int length>
  52 inline VectorN<Cmpt, length>::VectorN()
  53 {}
  54
  55
  56 // Construct given VectorSpace
  57 template <class Cmpt, int length>
  58 inline VectorN<Cmpt, length>::VectorN
  59 (
  60     const VectorSpace<VectorN<Cmpt, length>, Cmpt, length>& vs
  61 )
  62 :
  63     VectorSpace<VectorN<Cmpt, length>, Cmpt, length>(vs)
  64 {}
  65
  66
  67 // Construct given Cmpts
  68 template <class Cmpt, int length>
  69 inline VectorN<Cmpt, length>::VectorN(const Cmpt& vx)
  70 {
  71     VectorSpaceOps<VectorN<Cmpt, length>::nComponents,0>::eqOpS(*this, vx, eqOp<Cmpt>());
  72 }
  73
  74
  75 // Construct from Istream
  76 template <class Cmpt, int length>
  77 inline VectorN<Cmpt, length>::VectorN(Istream& is)
  78 :
  79     VectorSpace<VectorN<Cmpt, length>, Cmpt, length>(is)
  80 {}
  81
  82
  83 // * * * * * * * * * * * * * * * Member Operators  * * * * * * * * * * * * * //
  84
  85 template <class Cmpt, int length>
  86 inline const Cmpt& VectorN<Cmpt, length>::operator()(const direction i) const
  87 {
  88     return this->operator[](i);
  89 }
  90
  91
  92 template <class Cmpt, int length>
  93 inline Cmpt& VectorN<Cmpt, length>::operator()(const direction i)
  94 {
  95     return this->operator[](i);
  96 }
  97
  98
  99 //- Multiply components of VectorN by VectorN
 100 template<class Cmpt, int length>
 101 inline VectorN<Cmpt, length> VectorN<Cmpt, length>::cmptMultiply(const VectorN<Cmpt, length>& v)
 102 {
 103     VectorN<Cmpt, length> res;
 104     VectorSpaceOps<VectorN<Cmpt, length>::nComponents,0>::op(res, *this, v, multiplyOp<Cmpt>());
 105     return res;
 106 }
 107
 108
 109 //- Transform the spherical tensor
 110 //- The components are assumed to be individual scalars
 111 //- i.e. transform has no effect
 112 template<class Cmpt, int length>
 113 inline VectorN<Cmpt, length> transform
 114 (
 115     const tensor& tt,
 116     const VectorN<Cmpt, length>& v
 117 )
 118 {
 119     return v;
 120 }
 121
 122
 123 // * * * * * * * * * * * * * * * Global Operators  * * * * * * * * * * * * * //
 124
 125 template<class Cmpt, int length>
 126 class outerProduct<Cmpt, VectorN<Cmpt, length> >
 127 {
 128 public:
 129
 130     typedef VectorN<Cmpt, length> type;
 131 };
 132
 133
 134 template<class Cmpt, int length>
 135 class outerProduct<VectorN<Cmpt, length>, Cmpt>
 136 {
 137 public:
 138
 139     typedef VectorN<Cmpt, length> type;
 140 };
 141
 142
 143 template<class Cmpt, int length>
 144 class outerProduct<VectorN<Cmpt, length>, VectorN<Cmpt, length> >
 145 {
 146 public:
 147
 148     typedef TensorN<Cmpt, length> type;
 149 };
 150
 151
 152 //- Inner-product between a vector and a vector
 153 template <class Cmpt, int length>
 154 inline Cmpt operator&
 155 (
 156     const VectorN<Cmpt, length>& v1,
 157     const VectorN<Cmpt, length>& v2
 158 )
 159 {
 160     Cmpt res = pTraits<Cmpt>::zero;
 161     VectorSpaceOps<VectorN<Cmpt, length>::nComponents,0>::SopEqOpVV
 162         (res, v1, v2, plusEqOp<Cmpt>(), multiplyOp<Cmpt>());
 163     return res;
 164 }
 165
 166
 167 //- Componentwise division of scalar by VectorN
 168 template<class Cmpt, int length>
 169 inline VectorN<Cmpt, length>
 170 operator/(const scalar s, const VectorN<Cmpt, length>& v)
 171 {
 172     VectorN<Cmpt, length> res;
 173     VectorSpaceOps<VectorN<Cmpt, length>::nComponents,0>::opSV(res, s, v, divideOp3<Cmpt, scalar, Cmpt>());
 174     return res;
 175 }
 176
 177
 178 //- Multiply components of VectorN by VectorN
 179 template<class Cmpt, int length>
 180 inline VectorN<Cmpt, length> cmptMultiply(const VectorN<Cmpt, length>& v1, const VectorN<Cmpt, length>& v2)
 181 {
 182     VectorN<Cmpt, length> res;
 183     VectorSpaceOps<VectorN<Cmpt, length>::nComponents,0>::op(res, v1, v2, multiplyOp<Cmpt>());
 184     return res;
 185 }
 186
 187 //- Return the component sum
 188 // template <class Cmpt, int length>
 189 // inline Cmpt sum(const VectorN<Cmpt, length>& v)
 190 // {
 191 //     Cmpt result = pTraits<Cmpt>::zero;
 192 //     for(register label i=0; i<VectorN<Cmpt, length>::nComponents; i++)
 193 //     {
 194 //         result += v[i];
 195 //     }
 196 //     return result;
 197 // }
 198
 199
 200 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 201
 202 } // End namespace Foam
 203
 204 // ************************************************************************* //