src/thermophysicalModels/basic/psiThermo/hPsiThermo/hPsiThermo.C

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