src/thermophysicalModels/specie/thermo/specieThermo/specieThermoI.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 "specieThermo.H"
  27
  28 // * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
  29
  30 template<class thermo>
  31 inline Foam::specieThermo<thermo>::specieThermo
  32 (
  33     const thermo& sp
  34 )
  35 :
  36     thermo(sp)
  37 {}
  38
  39
  40 template<class thermo>
  41 inline Foam::scalar Foam::specieThermo<thermo>::T
  42 (
  43     scalar f,
  44     scalar T0,
  45     scalar (specieThermo<thermo>::*F)(const scalar) const,
  46     scalar (specieThermo<thermo>::*dFdT)(const scalar) const
  47 ) const
  48 {
  49     scalar Test = T0;
  50     scalar Tnew = T0;
  51     scalar Ttol = T0*tol_();
  52     int iter = 0;
  53
  54     do
  55     {
  56         // Limit the temperature jump in a single corrector to TJump_
  57         // HJ, 12/Oct/2010
  58
  59         Test = Tnew;
  60         Tnew = Test
  61             - Foam::min(((this->*F)(Test) - f)/(this->*dFdT)(Test), TJump_());
  62
  63         if (iter++ > maxIter_())
  64         {
  65             // Improvements: graceful exit with recovery.  HJ, 11/Oct/2010
  66             InfoIn
  67             (
  68                 "specieThermo<thermo>::T(scalar f, scalar T0, "
  69                 "scalar (specieThermo<thermo>::*F)(const scalar) const, "
  70                 "scalar (specieThermo<thermo>::*dFdT)(const scalar) const"
  71                 ") const"
  72             )   << "Maximum number of iterations exceeded.  T0 = "
  73                 << T0 << " F = " << (this->*F)(Test)
  74                 << " dFdT = " << (this->*dFdT)(Test)
  75                 << endl;
  76
  77             // Use value where dFdT is calculated using T0.  HJ, 11/Oct/2010
  78             Tnew = f/(this->*dFdT)(T0);
  79
  80             return Tnew;
  81         }
  82
  83     } while (mag(Tnew - Test) > Ttol);
  84
  85     return Tnew;
  86 }
  87
  88
  89 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
  90
  91 template<class thermo>
  92 inline Foam::specieThermo<thermo>::specieThermo
  93 (
  94     const word& name,
  95     const specieThermo& st
  96 )
  97 :
  98     thermo(name, st)
  99 {}
 100
 101
 102 // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
 103
 104 template<class thermo>
 105 inline Foam::scalar Foam::specieThermo<thermo>::cv(const scalar T) const
 106 {
 107     return this->cp(T) - this->RR();
 108 }
 109
 110
 111 template<class thermo>
 112 inline Foam::scalar Foam::specieThermo<thermo>::gamma(const scalar T) const
 113 {
 114     scalar CP = this->cp(T);
 115     return CP/(CP - this->RR());
 116 }
 117
 118
 119 template<class thermo>
 120 inline Foam::scalar Foam::specieThermo<thermo>::e(const scalar T) const
 121 {
 122     return this->h(T) - this->RR()*(T - this->Tstd());
 123 }
 124
 125
 126 template<class thermo>
 127 inline Foam::scalar Foam::specieThermo<thermo>::es(const scalar T) const
 128 {
 129     return this->hs(T) - this->RR()*(T - this->Tstd());
 130 }
 131
 132
 133 template<class thermo>
 134 inline Foam::scalar Foam::specieThermo<thermo>::g(const scalar T) const
 135 {
 136     return this->h(T) - T*this->s(T);
 137 }
 138
 139
 140 template<class thermo>
 141 inline Foam::scalar Foam::specieThermo<thermo>::a(const scalar T) const
 142 {
 143     return this->e(T) - T*this->s(T);
 144 }
 145
 146
 147 template<class thermo>
 148 inline Foam::scalar Foam::specieThermo<thermo>::Cp(const scalar T) const
 149 {
 150     return this->cp(T)/this->W();
 151 }
 152
 153
 154 template<class thermo>
 155 inline Foam::scalar Foam::specieThermo<thermo>::Cv(const scalar T) const
 156 {
 157     return this->cv(T)/this->W();
 158 }
 159
 160
 161 template<class thermo>
 162 inline Foam::scalar Foam::specieThermo<thermo>::H(const scalar T) const
 163 {
 164     return this->h(T)/this->W();
 165 }
 166
 167
 168 template<class thermo>
 169 inline Foam::scalar Foam::specieThermo<thermo>::Hs(const scalar T) const
 170 {
 171     return this->hs(T)/this->W();
 172 }
 173
 174
 175 template<class thermo>
 176 inline Foam::scalar Foam::specieThermo<thermo>::Hc() const
 177 {
 178     return this->hc()/this->W();
 179 }
 180
 181
 182 template<class thermo>
 183 inline Foam::scalar Foam::specieThermo<thermo>::S(const scalar T) const
 184 {
 185     return this->s(T)/this->W();
 186 }
 187
 188
 189 template<class thermo>
 190 inline Foam::scalar Foam::specieThermo<thermo>::E(const scalar T) const
 191 {
 192     return this->e(T)/this->W();
 193 }
 194
 195
 196 template<class thermo>
 197 inline Foam::scalar Foam::specieThermo<thermo>::G(const scalar T) const
 198 {
 199     return this->g(T)/this->W();
 200 }
 201
 202
 203 template<class thermo>
 204 inline Foam::scalar Foam::specieThermo<thermo>::A(const scalar T) const
 205 {
 206     return this->a(T)/this->W();
 207 }
 208
 209
 210 template<class thermo>
 211 inline Foam::scalar Foam::specieThermo<thermo>::K(const scalar T) const
 212 {
 213     scalar arg = -this->nMoles()*this->g(T)/(this->RR()*T);
 214
 215     if (arg < 600.0)
 216     {
 217         return ::exp(arg);
 218     }
 219     else
 220     {
 221         return VGREAT;
 222     }
 223 }
 224
 225
 226 template<class thermo>
 227 inline Foam::scalar Foam::specieThermo<thermo>::Kp(const scalar T) const
 228 {
 229     return K(T);
 230 }
 231
 232
 233 template<class thermo>
 234 inline Foam::scalar Foam::specieThermo<thermo>::Kc(const scalar T) const
 235 {
 236     if (equal(this->nMoles(), SMALL))
 237     {
 238         return Kp(T);
 239     }
 240     else
 241     {
 242         return Kp(T)*pow(this->Pstd()/(this->RR()*T), this->nMoles());
 243     }
 244 }
 245
 246
 247 template<class thermo>
 248 inline Foam::scalar Foam::specieThermo<thermo>::Kx
 249 (
 250     const scalar T,
 251     const scalar p
 252 ) const
 253 {
 254     if (equal(this->nMoles(), SMALL))
 255     {
 256         return Kp(T);
 257     }
 258     else
 259     {
 260         return Kp(T)*pow(this->Pstd()/p, this->nMoles());
 261     }
 262 }
 263
 264
 265 template<class thermo>
 266 inline Foam::scalar Foam::specieThermo<thermo>::Kn
 267 (
 268     const scalar T,
 269     const scalar p,
 270     const scalar n
 271 ) const
 272 {
 273     if (equal(this->nMoles(), SMALL))
 274     {
 275         return Kp(T);
 276     }
 277     else
 278     {
 279         return Kp(T)*pow(n*this->Pstd()/p, this->nMoles());
 280     }
 281 }
 282
 283
 284 template<class thermo>
 285 inline Foam::scalar Foam::specieThermo<thermo>::TH
 286 (
 287     const scalar h,
 288     const scalar T0
 289 ) const
 290 {
 291     return T(h, T0, &specieThermo<thermo>::H, &specieThermo<thermo>::Cp);
 292 }
 293
 294
 295 template<class thermo>
 296 inline Foam::scalar Foam::specieThermo<thermo>::THs
 297 (
 298     const scalar hs,
 299     const scalar T0
 300 ) const
 301 {
 302     return T(hs, T0, &specieThermo<thermo>::Hs, &specieThermo<thermo>::Cp);
 303 }
 304
 305
 306 template<class thermo>
 307 inline Foam::scalar Foam::specieThermo<thermo>::TE
 308 (
 309     const scalar e,
 310     const scalar T0
 311 ) const
 312 {
 313     return T(e, T0, &specieThermo<thermo>::E, &specieThermo<thermo>::Cv);
 314 }
 315
 316
 317 // * * * * * * * * * * * * * * * Member Operators  * * * * * * * * * * * * * //
 318
 319 template<class thermo>
 320 inline void Foam::specieThermo<thermo>::operator+=
 321 (
 322     const specieThermo<thermo>& st
 323 )
 324 {
 325     thermo::operator+=(st);
 326 }
 327
 328 template<class thermo>
 329 inline void Foam::specieThermo<thermo>::operator-=
 330 (
 331     const specieThermo<thermo>& st
 332 )
 333 {
 334     thermo::operator-=(st);
 335 }
 336
 337 template<class thermo>
 338 inline void Foam::specieThermo<thermo>::operator*=(const scalar s)
 339 {
 340     thermo::operator*=(s);
 341 }
 342
 343
 344 // * * * * * * * * * * * * * * * Friend Operators  * * * * * * * * * * * * * //
 345
 346 template<class thermo>
 347 inline Foam::specieThermo<thermo> Foam::operator+
 348 (
 349     const specieThermo<thermo>& st1,
 350     const specieThermo<thermo>& st2
 351 )
 352 {
 353     return specieThermo<thermo>
 354     (
 355         static_cast<const thermo&>(st1) + static_cast<const thermo&>(st2)
 356     );
 357 }
 358
 359
 360 template<class thermo>
 361 inline Foam::specieThermo<thermo> Foam::operator-
 362 (
 363     const specieThermo<thermo>& st1,
 364     const specieThermo<thermo>& st2
 365 )
 366 {
 367     return specieThermo<thermo>
 368     (
 369         static_cast<const thermo&>(st1) - static_cast<const thermo&>(st2)
 370     );
 371 }
 372
 373
 374 template<class thermo>
 375 inline Foam::specieThermo<thermo> Foam::operator*
 376 (
 377     const scalar s,
 378     const specieThermo<thermo>& st
 379 )
 380 {
 381     return specieThermo<thermo>
 382     (
 383         s*static_cast<const thermo&>(st)
 384     );
 385 }
 386
 387
 388 template<class thermo>
 389 inline Foam::specieThermo<thermo> Foam::operator==
 390 (
 391     const specieThermo<thermo>& st1,
 392     const specieThermo<thermo>& st2
 393 )
 394 {
 395     return st2 - st1;
 396 }
 397
 398
 399 // ************************************************************************* //