src/turbulenceModels/incompressible/RAS/LaunderSharmaKE/LaunderSharmaKE.C

   1 /*---------------------------------------------------------------------------*\
   2   =========                 |
   3   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
   4    \\    /   O peration     |
   5     \\  /    A nd           | Copyright (C) 1991-2009 OpenCFD Ltd.
   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 "LaunderSharmaKE.H"
  28 #include "addToRunTimeSelectionTable.H"
  29
  30 #include "backwardsCompatibilityWallFunctions.H"
  31
  32 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
  33
  34 namespace Foam
  35 {
  36 namespace incompressible
  37 {
  38 namespace RASModels
  39 {
  40
  41 // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
  42
  43 defineTypeNameAndDebug(LaunderSharmaKE, 0);
  44 addToRunTimeSelectionTable(RASModel, LaunderSharmaKE, dictionary);
  45
  46 // * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * * //
  47
  48 tmp<volScalarField> LaunderSharmaKE::fMu() const
  49 {
  50     return exp(-3.4/sqr(scalar(1) + sqr(k_)/(nu()*epsilonTilda_)/50.0));
  51 }
  52
  53
  54 tmp<volScalarField> LaunderSharmaKE::f2() const
  55 {
  56     return
  57         scalar(1)
  58       - 0.3*exp(-min(sqr(sqr(k_)/(nu()*epsilonTilda_)), scalar(50.0)));
  59 }
  60
  61
  62 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
  63
  64 LaunderSharmaKE::LaunderSharmaKE
  65 (
  66     const volVectorField& U,
  67     const surfaceScalarField& phi,
  68     transportModel& lamTransportModel
  69 )
  70 :
  71     RASModel(typeName, U, phi, lamTransportModel),
  72
  73     Cmu_
  74     (
  75         dimensioned<scalar>::lookupOrAddToDict
  76         (
  77             "Cmu",
  78             coeffDict_,
  79             0.09
  80         )
  81     ),
  82     C1_
  83     (
  84         dimensioned<scalar>::lookupOrAddToDict
  85         (
  86             "C1",
  87             coeffDict_,
  88             1.44
  89         )
  90     ),
  91     C2_
  92     (
  93         dimensioned<scalar>::lookupOrAddToDict
  94         (
  95             "C2",
  96             coeffDict_,
  97             1.92
  98         )
  99     ),
 100     sigmaEps_
 101     (
 102         dimensioned<scalar>::lookupOrAddToDict
 103         (
 104             "sigmaEps",
 105             coeffDict_,
 106             1.3
 107         )
 108     ),
 109
 110     k_
 111     (
 112         IOobject
 113         (
 114             "k",
 115             runTime_.timeName(),
 116             mesh_,
 117             IOobject::MUST_READ,
 118             IOobject::AUTO_WRITE
 119         ),
 120         mesh_
 121     ),
 122
 123     epsilonTilda_
 124     (
 125         IOobject
 126         (
 127             "epsilon",
 128             runTime_.timeName(),
 129             mesh_,
 130             IOobject::MUST_READ,
 131             IOobject::AUTO_WRITE
 132         ),
 133         mesh_
 134     ),
 135
 136     nut_
 137     (
 138         IOobject
 139         (
 140             "nut",
 141             runTime_.timeName(),
 142             mesh_,
 143             IOobject::NO_READ,
 144             IOobject::AUTO_WRITE
 145         ),
 146         autoCreateNut("nut", mesh_)
 147     )
 148 {
 149     nut_ = Cmu_*fMu()*sqr(k_)/(epsilonTilda_ + epsilonSmall_);
 150     nut_.correctBoundaryConditions();
 151
 152     printCoeffs();
 153 }
 154
 155
 156 // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
 157
 158 tmp<volSymmTensorField> LaunderSharmaKE::R() const
 159 {
 160     return tmp<volSymmTensorField>
 161     (
 162         new volSymmTensorField
 163         (
 164             IOobject
 165             (
 166                 "R",
 167                 runTime_.timeName(),
 168                 mesh_,
 169                 IOobject::NO_READ,
 170                 IOobject::NO_WRITE
 171             ),
 172             ((2.0/3.0)*I)*k_ - nut_*twoSymm(fvc::grad(U_)),
 173             k_.boundaryField().types()
 174         )
 175     );
 176 }
 177
 178
 179 tmp<volSymmTensorField> LaunderSharmaKE::devReff() const
 180 {
 181     return tmp<volSymmTensorField>
 182     (
 183         new volSymmTensorField
 184         (
 185             IOobject
 186             (
 187                 "devRhoReff",
 188                 runTime_.timeName(),
 189                 mesh_,
 190                 IOobject::NO_READ,
 191                 IOobject::NO_WRITE
 192             ),
 193            -nuEff()*dev(twoSymm(fvc::grad(U_)))
 194         )
 195     );
 196 }
 197
 198
 199 tmp<fvVectorMatrix> LaunderSharmaKE::divDevReff(volVectorField& U) const
 200 {
 201     return
 202     (
 203       - fvm::laplacian(nuEff(), U)
 204       - fvc::div(nuEff()*dev(fvc::grad(U)().T()))
 205     );
 206 }
 207
 208
 209 bool LaunderSharmaKE::read()
 210 {
 211     if (RASModel::read())
 212     {
 213         Cmu_.readIfPresent(coeffDict());
 214         C1_.readIfPresent(coeffDict());
 215         C2_.readIfPresent(coeffDict());
 216         sigmaEps_.readIfPresent(coeffDict());
 217
 218         return true;
 219     }
 220     else
 221     {
 222         return false;
 223     }
 224 }
 225
 226
 227 void LaunderSharmaKE::correct()
 228 {
 229     RASModel::correct();
 230
 231     if (!turbulence_)
 232     {
 233         return;
 234     }
 235
 236     volScalarField S2 = 2*magSqr(symm(fvc::grad(U_)));
 237
 238     volScalarField G = nut_*S2;
 239
 240     volScalarField E = 2.0*nu()*nut_*fvc::magSqrGradGrad(U_);
 241     volScalarField D = 2.0*nu()*magSqr(fvc::grad(sqrt(k_)));
 242
 243
 244     // Dissipation rate equation
 245
 246     tmp<fvScalarMatrix> epsEqn
 247     (
 248         fvm::ddt(epsilonTilda_)
 249       + fvm::div(phi_, epsilonTilda_)
 250       - fvm::laplacian(DepsilonEff(), epsilonTilda_)
 251      ==
 252         C1_*G*epsilonTilda_/k_
 253       - fvm::Sp(C2_*f2()*epsilonTilda_/k_, epsilonTilda_)
 254       + E
 255     );
 256
 257     epsEqn().relax();
 258     solve(epsEqn);
 259     bound(epsilonTilda_, epsilon0_);
 260
 261
 262     // Turbulent kinetic energy equation
 263
 264     tmp<fvScalarMatrix> kEqn
 265     (
 266         fvm::ddt(k_)
 267       + fvm::div(phi_, k_)
 268       - fvm::laplacian(DkEff(), k_)
 269      ==
 270         G - fvm::Sp((epsilonTilda_ + D)/k_, k_)
 271     );
 272
 273     kEqn().relax();
 274     solve(kEqn);
 275     bound(k_, k0_);
 276
 277
 278     // Re-calculate viscosity
 279     nut_ = Cmu_*fMu()*sqr(k_)/epsilonTilda_;
 280     nut_.correctBoundaryConditions();
 281 }
 282
 283
 284 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 285
 286 } // End namespace RASModels
 287 } // End namespace incompressible
 288 } // End namespace Foam
 289
 290 // ************************************************************************* //