src/thermophysicalModels/specie/transport/sutherland/sutherlandTransportI.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 \*---------------------------------------------------------------------------*/
  25
  26 #include "specie.H"
  27
  28 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
  29
  30 namespace Foam
  31 {
  32
  33 // * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
  34
  35 template<class thermo>
  36 inline void sutherlandTransport<thermo>::calcCoeffs
  37 (
  38     const scalar mu1, const scalar T1,
  39     const scalar mu2, const scalar T2
  40 )
  41 {
  42     scalar rootT1 = sqrt(T1);
  43     scalar mu1rootT2 = mu1*sqrt(T2);
  44     scalar mu2rootT1 = mu2*rootT1;
  45
  46     Ts = (mu2rootT1 - mu1rootT2)/(mu1rootT2/T1 - mu2rootT1/T2);
  47
  48     As = mu1*(1.0 + Ts/T1)/rootT1;
  49 }
  50
  51
  52 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
  53
  54 // Construct from components
  55 template<class thermo>
  56 inline sutherlandTransport<thermo>::sutherlandTransport
  57 (
  58     const thermo& t,
  59     const scalar as,
  60     const scalar ts
  61 )
  62 :
  63     thermo(t),
  64     As(as),
  65     Ts(ts)
  66 {}
  67
  68
  69 // Construct from components
  70 template<class thermo>
  71 inline sutherlandTransport<thermo>::sutherlandTransport
  72 (
  73     const thermo& t,
  74     const scalar mu1, const scalar T1,
  75     const scalar mu2, const scalar T2
  76 )
  77 :
  78     thermo(t)
  79 {
  80     calcCoeffs(mu1, T1, mu2, T2);
  81 }
  82
  83
  84 //- Construct as named copy
  85 template<class thermo>
  86 inline sutherlandTransport<thermo>::sutherlandTransport
  87 (
  88     const word& name,
  89     const sutherlandTransport& st
  90 )
  91 :
  92     thermo(name, st),
  93     As(st.As),
  94     Ts(st.Ts)
  95 {}
  96
  97
  98 // Construct and return a clone
  99 template<class thermo>
 100 inline autoPtr<sutherlandTransport<thermo> > sutherlandTransport<thermo>::clone
 101 () const
 102 {
 103     return autoPtr<sutherlandTransport<thermo> >
 104     (
 105         new sutherlandTransport<thermo>(*this)
 106     );
 107 }
 108
 109
 110 // Selector from Istream
 111 template<class thermo>
 112 inline autoPtr<sutherlandTransport<thermo> > sutherlandTransport<thermo>::New
 113 (
 114     Istream& is
 115 )
 116 {
 117     return autoPtr<sutherlandTransport<thermo> >
 118     (
 119         new sutherlandTransport<thermo>(is)
 120     );
 121 }
 122
 123
 124 // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
 125
 126 // Dynamic viscosity [kg/ms]
 127 template<class thermo>
 128 inline scalar sutherlandTransport<thermo>::mu(const scalar T) const
 129 {
 130     return As*::sqrt(T)/(1.0 + Ts/T);
 131 }
 132
 133
 134 // Thermal conductivity [W/mK]
 135 template<class thermo>
 136 inline scalar sutherlandTransport<thermo>::kappa(const scalar T) const
 137 {
 138     scalar Cv_ = this->Cv(T);
 139     return mu(T)*Cv_*(1.32 + 1.77*this->R()/Cv_);
 140 }
 141
 142
 143 // Thermal diffusivity for enthalpy [kg/ms]
 144 template<class thermo>
 145 inline scalar sutherlandTransport<thermo>::alpha(const scalar T) const
 146 {
 147     scalar Cv_ = this->Cv(T);
 148     scalar R_ = this->R();
 149     scalar Cp_ = Cv_ + R_;
 150
 151     scalar deltaT = T - specie::Tstd();
 152     scalar CpBar =
 153         (deltaT*(this->H(T) - this->H(specie::Tstd())) + Cp_)/(sqr(deltaT) + 1);
 154
 155     return mu(T)*Cv_*(1.32 + 1.77*this->R()/Cv_)/CpBar;
 156 }
 157
 158
 159 // * * * * * * * * * * * * * * * Member Operators  * * * * * * * * * * * * * //
 160
 161 template<class thermo>
 162 inline sutherlandTransport<thermo>& sutherlandTransport<thermo>::operator=
 163 (
 164     const sutherlandTransport<thermo>& st
 165 )
 166 {
 167     thermo::operator=(st);
 168
 169     As = st.As;
 170     Ts = st.Ts;
 171
 172     return *this;
 173 }
 174
 175
 176 template<class thermo>
 177 inline void Foam::sutherlandTransport<thermo>::operator+=
 178 (
 179     const sutherlandTransport<thermo>& st
 180 )
 181 {
 182     scalar molr1 = this->nMoles();
 183
 184     thermo::operator+=(st);
 185
 186     molr1 /= this->nMoles();
 187     scalar molr2 = st.nMoles()/this->nMoles();
 188
 189     As = molr1*As + molr2*st.As;
 190     Ts = molr1*Ts + molr2*st.Ts;
 191 }
 192
 193
 194 template<class thermo>
 195 inline void Foam::sutherlandTransport<thermo>::operator-=
 196 (
 197     const sutherlandTransport<thermo>& st
 198 )
 199 {
 200     scalar molr1 = this->nMoles();
 201
 202     thermo::operator-=(st);
 203
 204     molr1 /= this->nMoles();
 205     scalar molr2 = st.nMoles()/this->nMoles();
 206
 207     As = molr1*As - molr2*st.As;
 208     Ts = molr1*Ts - molr2*st.Ts;
 209 }
 210
 211
 212 template<class thermo>
 213 inline void Foam::sutherlandTransport<thermo>::operator*=
 214 (
 215     const scalar s
 216 )
 217 {
 218     thermo::operator*=(s);
 219 }
 220
 221
 222 // * * * * * * * * * * * * * * * Friend Operators  * * * * * * * * * * * * * //
 223
 224 template<class thermo>
 225 inline sutherlandTransport<thermo> operator+
 226 (
 227     const sutherlandTransport<thermo>& st1,
 228     const sutherlandTransport<thermo>& st2
 229 )
 230 {
 231     thermo t
 232     (
 233         static_cast<const thermo&>(st1) + static_cast<const thermo&>(st2)
 234     );
 235
 236     scalar molr1 = st1.nMoles()/t.nMoles();
 237     scalar molr2 = st2.nMoles()/t.nMoles();
 238
 239     return sutherlandTransport<thermo>
 240     (
 241         t,
 242         molr1*st1.As + molr2*st2.As,
 243         molr1*st1.Ts + molr2*st2.Ts
 244     );
 245 }
 246
 247
 248 template<class thermo>
 249 inline sutherlandTransport<thermo> operator-
 250 (
 251     const sutherlandTransport<thermo>& st1,
 252     const sutherlandTransport<thermo>& st2
 253 )
 254 {
 255     thermo t
 256     (
 257         static_cast<const thermo&>(st1) - static_cast<const thermo&>(st2)
 258     );
 259
 260     scalar molr1 = st1.nMoles()/t.nMoles();
 261     scalar molr2 = st2.nMoles()/t.nMoles();
 262
 263     return sutherlandTransport<thermo>
 264     (
 265         t,
 266         molr1*st1.As - molr2*st2.As,
 267         molr1*st1.Ts - molr2*st2.Ts
 268     );
 269 }
 270
 271
 272 template<class thermo>
 273 inline sutherlandTransport<thermo> operator*
 274 (
 275     const scalar s,
 276     const sutherlandTransport<thermo>& st
 277 )
 278 {
 279     return sutherlandTransport<thermo>
 280     (
 281         s*static_cast<const thermo&>(st),
 282         st.As,
 283         st.Ts
 284     );
 285 }
 286
 287
 288 template<class thermo>
 289 inline sutherlandTransport<thermo> operator==
 290 (
 291     const sutherlandTransport<thermo>& st1,
 292     const sutherlandTransport<thermo>& st2
 293 )
 294 {
 295     return st2 - st1;
 296 }
 297
 298
 299 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 300
 301 } // End namespace Foam
 302
 303 // ************************************************************************* //