src/turbulenceModels/compressible/turbulenceModel/laminar/laminar.C

   1 /*---------------------------------------------------------------------------*\
   2   =========                 |
   3   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
   4    \\    /   O peration     |
   5     \\  /    A nd           | Copyright (C) 2011 OpenFOAM Foundation
   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
  13     the Free Software Foundation, either version 3 of the License, or
  14     (at your 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, see <http://www.gnu.org/licenses/>.
  23
  24 \*---------------------------------------------------------------------------*/
  25
  26 #include "laminar.H"
  27 #include "Time.H"
  28 #include "volFields.H"
  29 #include "fvcGrad.H"
  30 #include "fvcDiv.H"
  31 #include "fvmLaplacian.H"
  32 #include "addToRunTimeSelectionTable.H"
  33
  34
  35 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
  36
  37 namespace Foam
  38 {
  39 namespace compressible
  40 {
  41
  42 // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
  43
  44 defineTypeNameAndDebug(laminar, 0);
  45 addToRunTimeSelectionTable(turbulenceModel, laminar, turbulenceModel);
  46
  47 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
  48
  49 laminar::laminar
  50 (
  51     const volScalarField& rho,
  52     const volVectorField& U,
  53     const surfaceScalarField& phi,
  54     const basicThermo& thermophysicalModel,
  55     const word& turbulenceModelName
  56 )
  57 :
  58     turbulenceModel(rho, U, phi, thermophysicalModel, turbulenceModelName)
  59 {}
  60
  61
  62 // * * * * * * * * * * * * * * * * * Selectors * * * * * * * * * * * * * * * //
  63
  64 autoPtr<laminar> laminar::New
  65 (
  66     const volScalarField& rho,
  67     const volVectorField& U,
  68     const surfaceScalarField& phi,
  69     const basicThermo& thermophysicalModel,
  70     const word& turbulenceModelName
  71 )
  72 {
  73     return autoPtr<laminar>
  74     (
  75         new laminar(rho, U, phi, thermophysicalModel, turbulenceModelName)
  76     );
  77 }
  78
  79
  80 // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
  81
  82 tmp<volScalarField> laminar::mut() const
  83 {
  84     return tmp<volScalarField>
  85     (
  86         new volScalarField
  87         (
  88             IOobject
  89             (
  90                 "mut",
  91                 runTime_.timeName(),
  92                 mesh_,
  93                 IOobject::NO_READ,
  94                 IOobject::NO_WRITE
  95             ),
  96             mesh_,
  97             dimensionedScalar("mut", mu().dimensions(), 0.0)
  98         )
  99     );
 100 }
 101
 102
 103 tmp<volScalarField> laminar::alphat() const
 104 {
 105     return tmp<volScalarField>
 106     (
 107         new volScalarField
 108         (
 109             IOobject
 110             (
 111                 "alphat",
 112                 runTime_.timeName(),
 113                 mesh_,
 114                 IOobject::NO_READ,
 115                 IOobject::NO_WRITE
 116             ),
 117             mesh_,
 118             dimensionedScalar("alphat", alpha().dimensions(), 0.0)
 119         )
 120     );
 121 }
 122
 123
 124 tmp<volScalarField> laminar::k() const
 125 {
 126     return tmp<volScalarField>
 127     (
 128         new volScalarField
 129         (
 130             IOobject
 131             (
 132                 "k",
 133                 runTime_.timeName(),
 134                 mesh_,
 135                 IOobject::NO_READ,
 136                 IOobject::NO_WRITE
 137             ),
 138             mesh_,
 139             dimensionedScalar("k", sqr(U_.dimensions()), 0.0)
 140         )
 141     );
 142 }
 143
 144
 145 tmp<volScalarField> laminar::epsilon() const
 146 {
 147     return tmp<volScalarField>
 148     (
 149         new volScalarField
 150         (
 151             IOobject
 152             (
 153                 "epsilon",
 154                 runTime_.timeName(),
 155                 mesh_,
 156                 IOobject::NO_READ,
 157                 IOobject::NO_WRITE
 158             ),
 159             mesh_,
 160             dimensionedScalar
 161             (
 162                 "epsilon", sqr(U_.dimensions())/dimTime, 0.0
 163             )
 164         )
 165     );
 166 }
 167
 168
 169 tmp<volSymmTensorField> laminar::R() const
 170 {
 171     return tmp<volSymmTensorField>
 172     (
 173         new volSymmTensorField
 174         (
 175             IOobject
 176             (
 177                 "R",
 178                 runTime_.timeName(),
 179                 mesh_,
 180                 IOobject::NO_READ,
 181                 IOobject::NO_WRITE
 182             ),
 183             mesh_,
 184             dimensionedSymmTensor
 185             (
 186                 "R", sqr(U_.dimensions()), symmTensor::zero
 187             )
 188         )
 189     );
 190 }
 191
 192
 193 tmp<volSymmTensorField> laminar::devRhoReff() const
 194 {
 195     return tmp<volSymmTensorField>
 196     (
 197         new volSymmTensorField
 198         (
 199             IOobject
 200             (
 201                 "devRhoReff",
 202                 runTime_.timeName(),
 203                 mesh_,
 204                 IOobject::NO_READ,
 205                 IOobject::NO_WRITE
 206             ),
 207            -mu()*dev(twoSymm(fvc::grad(U_)))
 208         )
 209     );
 210 }
 211
 212
 213 tmp<fvVectorMatrix> laminar::divDevRhoReff(volVectorField& U) const
 214 {
 215     return
 216     (
 217       - fvm::laplacian(muEff(), U)
 218       - fvc::div(muEff()*dev2(T(fvc::grad(U))))
 219     );
 220 }
 221
 222
 223 void laminar::correct()
 224 {
 225     turbulenceModel::correct();
 226 }
 227
 228
 229 bool laminar::read()
 230 {
 231     return true;
 232 }
 233
 234
 235 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 236
 237 } // End namespace incompressible
 238 } // End namespace Foam
 239
 240 // ************************************************************************* //