src/OpenFOAM/primitives/SphericalTensor/SphericalTensorI.H

   1 /*---------------------------------------------------------------------------*\
   2   =========                 |
   3   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
   4    \\    /   O peration     |
   5     \\  /    A nd           | Copyright (C) 1991-2008 OpenCFD Ltd.
   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 #include "Vector.H"
  28
  29 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
  30
  31 namespace Foam
  32 {
  33
  34 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
  35
  36 // Construct null
  37 template <class Cmpt>
  38 inline SphericalTensor<Cmpt>::SphericalTensor()
  39 {}
  40
  41
  42 // Construct given VectorSpace
  43 template <class Cmpt>
  44 inline SphericalTensor<Cmpt>::SphericalTensor
  45 (
  46     const VectorSpace<SphericalTensor<Cmpt>, Cmpt, 1>& vs
  47 )
  48 :
  49     VectorSpace<SphericalTensor<Cmpt>, Cmpt, 1>(vs)
  50 {}
  51
  52
  53 // Construct given three Cmpts
  54 template <class Cmpt>
  55 inline SphericalTensor<Cmpt>::SphericalTensor(const Cmpt& stii)
  56 {
  57     this->v_[II] = stii;
  58 }
  59
  60
  61 // Construct from Istream
  62 template <class Cmpt>
  63 inline SphericalTensor<Cmpt>::SphericalTensor(Istream& is)
  64 :
  65     VectorSpace<SphericalTensor<Cmpt>, Cmpt, 1>(is)
  66 {}
  67
  68
  69 // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
  70
  71 template <class Cmpt>
  72 inline const Cmpt&  SphericalTensor<Cmpt>::ii() const
  73 {
  74     return this->v_[II];
  75 }
  76
  77
  78 template <class Cmpt>
  79 inline Cmpt& SphericalTensor<Cmpt>::ii()
  80 {
  81     return this->v_[II];
  82 }
  83
  84
  85 template <class Cmpt>
  86 inline const SphericalTensor<Cmpt>& SphericalTensor<Cmpt>::T() const
  87 {
  88     return *this;
  89 }
  90
  91
  92 // * * * * * * * * * * * * * * * Global Operators  * * * * * * * * * * * * * //
  93
  94 //- Inner-product between two spherical tensors
  95 template <class Cmpt>
  96 inline SphericalTensor<Cmpt>
  97 operator&(const SphericalTensor<Cmpt>& st1, const SphericalTensor<Cmpt>& st2)
  98 {
  99     return SphericalTensor<Cmpt>(st1.ii()*st2.ii());
 100 }
 101
 102
 103 //- Inner-product between a spherical tensor and a vector
 104 template <class Cmpt>
 105 inline Vector<Cmpt>
 106 operator&(const SphericalTensor<Cmpt>& st, const Vector<Cmpt>& v)
 107 {
 108     return Vector<Cmpt>
 109     (
 110         st.ii()*v.x(),
 111                        st.ii()*v.y(),
 112                                       st.ii()*v.z()
 113     );
 114 }
 115
 116
 117 //- Inner-product between a vector and a spherical tensor
 118 template <class Cmpt>
 119 inline Vector<Cmpt>
 120 operator&(const Vector<Cmpt>& v, const SphericalTensor<Cmpt>& st)
 121 {
 122     return Vector<Cmpt>
 123     (
 124         v.x()*st.ii(),
 125                        v.y()*st.ii(),
 126                                       v.z()*st.ii()
 127     );
 128 }
 129
 130
 131 //- Double-dot-product between a spherical tensor and a spherical tensor
 132 template <class Cmpt>
 133 inline Cmpt
 134 operator&&(const SphericalTensor<Cmpt>& st1, const SphericalTensor<Cmpt>& st2)
 135 {
 136     return 3*st1.ii()*st2.ii();
 137 }
 138
 139
 140 //- Division of a scalar by a sphericalTensor
 141 template <class Cmpt>
 142 inline SphericalTensor<Cmpt>
 143 operator/(const scalar s, const SphericalTensor<Cmpt>& st)
 144 {
 145     return SphericalTensor<Cmpt>(s/st.ii());
 146 }
 147
 148
 149 template <class Cmpt>
 150 inline Cmpt magSqr(const SphericalTensor<Cmpt>& st)
 151 {
 152     return 3*magSqr(st.ii());
 153 }
 154
 155
 156 //- Return the trace of a spherical tensor
 157 template <class Cmpt>
 158 inline Cmpt tr(const SphericalTensor<Cmpt>& st)
 159 {
 160     return 3*st.ii();
 161 }
 162
 163
 164 //- Return the spherical part of a spherical tensor, i.e. itself
 165 template <class Cmpt>
 166 inline SphericalTensor<Cmpt> sph(const SphericalTensor<Cmpt>& st)
 167 {
 168     return st;
 169 }
 170
 171
 172 //- Return the determinant of a spherical tensor
 173 template <class Cmpt>
 174 inline Cmpt det(const SphericalTensor<Cmpt>& st)
 175 {
 176     return st.ii()*st.ii()*st.ii();
 177 }
 178
 179
 180 //- Return the inverse of a symmetric tensor
 181 template <class Cmpt>
 182 inline SphericalTensor<Cmpt> inv(const SphericalTensor<Cmpt>& st)
 183 {
 184     return SphericalTensor<Cmpt>(1.0/st.ii());
 185 }
 186
 187
 188 template<class Cmpt>
 189 class outerProduct<SphericalTensor<Cmpt>, Cmpt>
 190 {
 191 public:
 192
 193     typedef SphericalTensor<Cmpt> type;
 194 };
 195
 196 template<class Cmpt>
 197 class outerProduct<Cmpt, SphericalTensor<Cmpt> >
 198 {
 199 public:
 200
 201     typedef SphericalTensor<Cmpt> type;
 202 };
 203
 204
 205 #ifndef __CINT__
 206 template<class Cmpt>
 207 class innerProduct<SphericalTensor<Cmpt>, SphericalTensor<Cmpt> >
 208 {
 209 public:
 210
 211     typedef SphericalTensor<Cmpt> type;
 212 };
 213
 214
 215 template<class Cmpt>
 216 class innerProduct<SphericalTensor<Cmpt>, Vector<Cmpt> >
 217 {
 218 public:
 219
 220     typedef Vector<Cmpt> type;
 221 };
 222
 223 template<class Cmpt>
 224 class innerProduct<Vector<Cmpt>, SphericalTensor<Cmpt> >
 225 {
 226 public:
 227
 228     typedef Vector<Cmpt> type;
 229 };
 230 #endif
 231
 232
 233 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 234
 235 } // End namespace Foam
 236
 237 // ************************************************************************* //