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