src/thermophysicalModels/basic/psiThermo/hsPsiThermo/hsPsiThermo.C

   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 "hsPsiThermo.H"
  27
  28 // * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
  29
  30 template<class MixtureType>
  31 void Foam::hsPsiThermo<MixtureType>::calculate()
  32 {
  33     const scalarField& hsCells = hs_.internalField();
  34     const scalarField& pCells = this->p_.internalField();
  35
  36     scalarField& TCells = this->T_.internalField();
  37     scalarField& psiCells = this->psi_.internalField();
  38     scalarField& muCells = this->mu_.internalField();
  39     scalarField& alphaCells = this->alpha_.internalField();
  40
  41     forAll(TCells, celli)
  42     {
  43         const typename MixtureType::thermoType& mixture_ =
  44             this->cellMixture(celli);
  45
  46         TCells[celli] = mixture_.THs(hsCells[celli], TCells[celli]);
  47         psiCells[celli] = mixture_.psi(pCells[celli], TCells[celli]);
  48
  49         muCells[celli] = mixture_.mu(TCells[celli]);
  50         alphaCells[celli] = mixture_.alpha(TCells[celli]);
  51     }
  52
  53     forAll(T_.boundaryField(), patchi)
  54     {
  55         fvPatchScalarField& pp = this->p_.boundaryField()[patchi];
  56         fvPatchScalarField& pT = this->T_.boundaryField()[patchi];
  57         fvPatchScalarField& ppsi = this->psi_.boundaryField()[patchi];
  58
  59         fvPatchScalarField& phs = hs_.boundaryField()[patchi];
  60
  61         fvPatchScalarField& pmu = this->mu_.boundaryField()[patchi];
  62         fvPatchScalarField& palpha = this->alpha_.boundaryField()[patchi];
  63
  64         if (pT.fixesValue())
  65         {
  66             forAll(pT, facei)
  67             {
  68                 const typename MixtureType::thermoType& mixture_ =
  69                     this->patchFaceMixture(patchi, facei);
  70
  71                 phs[facei] = mixture_.Hs(pT[facei]);
  72
  73                 ppsi[facei] = mixture_.psi(pp[facei], pT[facei]);
  74                 pmu[facei] = mixture_.mu(pT[facei]);
  75                 palpha[facei] = mixture_.alpha(pT[facei]);
  76             }
  77         }
  78         else
  79         {
  80             forAll(pT, facei)
  81             {
  82                 const typename MixtureType::thermoType& mixture_ =
  83                     this->patchFaceMixture(patchi, facei);
  84
  85                 pT[facei] = mixture_.THs(phs[facei], pT[facei]);
  86
  87                 ppsi[facei] = mixture_.psi(pp[facei], pT[facei]);
  88                 pmu[facei] = mixture_.mu(pT[facei]);
  89                 palpha[facei] = mixture_.alpha(pT[facei]);
  90             }
  91         }
  92     }
  93 }
  94
  95
  96 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
  97
  98 template<class MixtureType>
  99 Foam::hsPsiThermo<MixtureType>::hsPsiThermo
 100 (
 101     const fvMesh& mesh,
 102     const objectRegistry& obj
 103 )
 104 :
 105     basicPsiThermo(mesh, obj),
 106     MixtureType(*this, mesh, obj),
 107
 108     hs_
 109     (
 110         IOobject
 111         (
 112             "hs",
 113             mesh.time().timeName(),
 114             obj,
 115             IOobject::NO_READ,
 116             IOobject::NO_WRITE
 117         ),
 118         mesh,
 119         dimEnergy/dimMass,
 120         this->hBoundaryTypes()
 121     )
 122 {
 123     scalarField& hsCells = hs_.internalField();
 124     const scalarField& TCells = this->T_.internalField();
 125
 126     forAll(hsCells, celli)
 127     {
 128         hsCells[celli] = this->cellMixture(celli).Hs(TCells[celli]);
 129     }
 130
 131     forAll(hs_.boundaryField(), patchi)
 132     {
 133         hs_.boundaryField()[patchi] ==
 134             hs(this->T_.boundaryField()[patchi], patchi);
 135     }
 136
 137     hBoundaryCorrection(hs_);
 138
 139     calculate();
 140
 141     // Switch on saving old time
 142     this->psi_.oldTime();
 143 }
 144
 145
 146 // * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
 147
 148 template<class MixtureType>
 149 Foam::hsPsiThermo<MixtureType>::~hsPsiThermo()
 150 {}
 151
 152
 153 // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
 154
 155 template<class MixtureType>
 156 void Foam::hsPsiThermo<MixtureType>::correct()
 157 {
 158     if (debug)
 159     {
 160         Info<< "entering hsPsiThermo<MixtureType>::correct()" << endl;
 161     }
 162
 163     // force the saving of the old-time values
 164     this->psi_.oldTime();
 165
 166     calculate();
 167
 168     if (debug)
 169     {
 170         Info<< "exiting hsPsiThermo<MixtureType>::correct()" << endl;
 171     }
 172 }
 173
 174
 175 template<class MixtureType>
 176 Foam::tmp<Foam::scalarField> Foam::hsPsiThermo<MixtureType>::hs
 177 (
 178     const scalarField& T,
 179     const labelList& cells
 180 ) const
 181 {
 182     tmp<scalarField> ths(new scalarField(T.size()));
 183     scalarField& hs = ths();
 184
 185     forAll(T, celli)
 186     {
 187         hs[celli] = this->cellMixture(cells[celli]).Hs(T[celli]);
 188     }
 189
 190     return ths;
 191 }
 192
 193
 194 template<class MixtureType>
 195 Foam::tmp<Foam::scalarField> Foam::hsPsiThermo<MixtureType>::hs
 196 (
 197     const scalarField& T,
 198     const label patchi
 199 ) const
 200 {
 201     tmp<scalarField> ths(new scalarField(T.size()));
 202     scalarField& hs = ths();
 203
 204     forAll(T, facei)
 205     {
 206         hs[facei] = this->patchFaceMixture(patchi, facei).Hs(T[facei]);
 207     }
 208
 209     return ths;
 210 }
 211
 212
 213 template<class MixtureType>
 214 Foam::tmp<Foam::scalarField> Foam::hsPsiThermo<MixtureType>::Cp
 215 (
 216     const scalarField& T,
 217     const label patchi
 218 ) const
 219 {
 220     tmp<scalarField> tCp(new scalarField(T.size()));
 221     scalarField& cp = tCp();
 222
 223     forAll(T, facei)
 224     {
 225         cp[facei] = this->patchFaceMixture(patchi, facei).Cp(T[facei]);
 226     }
 227
 228     return tCp;
 229 }
 230
 231
 232 template<class MixtureType>
 233 Foam::tmp<Foam::scalarField> Foam::hsPsiThermo<MixtureType>::Cp
 234 (
 235     const scalarField& T,
 236     const labelList& cells
 237 ) const
 238 {
 239     tmp<scalarField> tCp(new scalarField(T.size()));
 240     scalarField& cp = tCp();
 241
 242     forAll(T, celli)
 243     {
 244         cp[celli] = this->cellMixture(cells[celli]).Cp(T[celli]);
 245     }
 246
 247     return tCp;
 248 }
 249
 250
 251 template<class MixtureType>
 252 Foam::tmp<Foam::volScalarField> Foam::hsPsiThermo<MixtureType>::Cp() const
 253 {
 254     const fvMesh& mesh = this->T_.mesh();
 255
 256     tmp<volScalarField> tCp
 257     (
 258         new volScalarField
 259         (
 260             IOobject
 261             (
 262                 "Cp",
 263                 mesh.time().timeName(),
 264                 T_.db(),
 265                 IOobject::NO_READ,
 266                 IOobject::NO_WRITE
 267             ),
 268             mesh,
 269             dimensionSet(0, 2, -2, -1, 0)
 270         )
 271     );
 272
 273     volScalarField& cp = tCp();
 274
 275     forAll(this->T_, celli)
 276     {
 277         cp[celli] = this->cellMixture(celli).Cp(this->T_[celli]);
 278     }
 279
 280     forAll(this->T_.boundaryField(), patchi)
 281     {
 282         const fvPatchScalarField& pT = this->T_.boundaryField()[patchi];
 283         fvPatchScalarField& pCp = cp.boundaryField()[patchi];
 284
 285         forAll(pT, facei)
 286         {
 287             pCp[facei] = this->patchFaceMixture(patchi, facei).Cp(pT[facei]);
 288         }
 289     }
 290
 291     return tCp;
 292 }
 293
 294
 295 template<class MixtureType>
 296 Foam::tmp<Foam::scalarField> Foam::hsPsiThermo<MixtureType>::Cv
 297 (
 298     const scalarField& T,
 299     const label patchi
 300 ) const
 301 {
 302     tmp<scalarField> tCv(new scalarField(T.size()));
 303     scalarField& cv = tCv();
 304
 305     forAll(T, facei)
 306     {
 307         cv[facei] = this->patchFaceMixture(patchi, facei).Cv(T[facei]);
 308     }
 309
 310     return tCv;
 311 }
 312
 313
 314 template<class MixtureType>
 315 Foam::tmp<Foam::volScalarField> Foam::hsPsiThermo<MixtureType>::Cv() const
 316 {
 317     const fvMesh& mesh = this->T_.mesh();
 318
 319     tmp<volScalarField> tCv
 320     (
 321         new volScalarField
 322         (
 323             IOobject
 324             (
 325                 "Cv",
 326                 mesh.time().timeName(),
 327                 T_.db(),
 328                 IOobject::NO_READ,
 329                 IOobject::NO_WRITE
 330             ),
 331             mesh,
 332             dimEnergy/dimMass/dimTemperature
 333         )
 334     );
 335
 336     volScalarField& cv = tCv();
 337
 338     forAll(this->T_, celli)
 339     {
 340         cv[celli] = this->cellMixture(celli).Cv(this->T_[celli]);
 341     }
 342
 343     forAll(this->T_.boundaryField(), patchi)
 344     {
 345         cv.boundaryField()[patchi] =
 346             Cv(this->T_.boundaryField()[patchi], patchi);
 347     }
 348
 349     return tCv;
 350 }
 351
 352
 353 template<class MixtureType>
 354 bool Foam::hsPsiThermo<MixtureType>::read()
 355 {
 356     if (basicPsiThermo::read())
 357     {
 358         MixtureType::read(*this);
 359         return true;
 360     }
 361     else
 362     {
 363         return false;
 364     }
 365 }
 366
 367
 368 // ************************************************************************* //