zhyang-dev/openfoam
1
0
Fork 0
mirror of https://develop.openfoam.com/Development/openfoam.git synced 2025-11-28 03:28:01 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Dynamic LES models: Rationalize naming

Browse Source
This commit is contained in:
Henry
2011-07-23 19:51:31 +01:00
parent 7ea0e85aca
commit 3f704d97ab
9 changed files with 193 additions and 189 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
src/turbulenceModels/compressible/LES/Make/files
View File

@ -5,7 +5,7 @@ GenSGSStress/GenSGSStress.C
Smagorinsky/Smagorinsky.C
oneEqEddy/oneEqEddy.C
lowReOneEqEddy/lowReOneEqEddy.C
dynOneEqEddy/dynOneEqEddy.C
homogeneousDynOneEqEddy/homogeneousDynOneEqEddy.C
DeardorffDiffStress/DeardorffDiffStress.C
SpalartAllmaras/SpalartAllmaras.C

18
src/turbulenceModels/compressible/LES/dynOneEqEddy/dynOneEqEddy.C → src/turbulenceModels/compressible/LES/homogeneousDynOneEqEddy/homogeneousDynOneEqEddy.C
View File

@ -23,7 +23,7 @@ License
\*---------------------------------------------------------------------------*/
#include "dynOneEqEddy.H"
#include "homogeneousDynOneEqEddy.H"
#include "addToRunTimeSelectionTable.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
@ -37,12 +37,12 @@ namespace LESModels
// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
defineTypeNameAndDebug(dynOneEqEddy, 0);
addToRunTimeSelectionTable(LESModel, dynOneEqEddy, dictionary);
defineTypeNameAndDebug(homogeneousDynOneEqEddy, 0);
addToRunTimeSelectionTable(LESModel, homogeneousDynOneEqEddy, dictionary);
// * * * * * * * * * * * * * Private Member Functions * * * * * * * * * * * //
void dynOneEqEddy::updateSubGridScaleFields(const volSymmTensorField& D)
void homogeneousDynOneEqEddy::updateSubGridScaleFields(const volSymmTensorField& D)
{
muSgs_ = ck_(D)*rho()*sqrt(k_)*delta();
muSgs_.correctBoundaryConditions();
@ -52,7 +52,7 @@ void dynOneEqEddy::updateSubGridScaleFields(const volSymmTensorField& D)
}
dimensionedScalar dynOneEqEddy::ck_(const volSymmTensorField& D) const
dimensionedScalar homogeneousDynOneEqEddy::ck_(const volSymmTensorField& D) const
{
volScalarField KK(0.5*(filter_(magSqr(U())) - magSqr(filter_(U()))));
@ -67,7 +67,7 @@ dimensionedScalar dynOneEqEddy::ck_(const volSymmTensorField& D) const
}
dimensionedScalar dynOneEqEddy::ce_(const volSymmTensorField& D) const
dimensionedScalar homogeneousDynOneEqEddy::ce_(const volSymmTensorField& D) const
{
volScalarField KK(0.5*(filter_(magSqr(U())) - magSqr(filter_(U()))));
@ -91,7 +91,7 @@ dimensionedScalar dynOneEqEddy::ce_(const volSymmTensorField& D) const
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
dynOneEqEddy::dynOneEqEddy
homogeneousDynOneEqEddy::homogeneousDynOneEqEddy
(
const volScalarField& rho,
const volVectorField& U,
@ -128,7 +128,7 @@ dynOneEqEddy::dynOneEqEddy
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
void dynOneEqEddy::correct(const tmp<volTensorField>& tgradU)
void homogeneousDynOneEqEddy::correct(const tmp<volTensorField>& tgradU)
{
const volTensorField& gradU = tgradU();
@ -158,7 +158,7 @@ void dynOneEqEddy::correct(const tmp<volTensorField>& tgradU)
}
bool dynOneEqEddy::read()
bool homogeneousDynOneEqEddy::read()
{
if (GenEddyVisc::read())
{

22
src/turbulenceModels/compressible/LES/dynOneEqEddy/dynOneEqEddy.H → src/turbulenceModels/compressible/LES/homogeneousDynOneEqEddy/homogeneousDynOneEqEddy.H
View File

@ -22,7 +22,7 @@ License
along with OpenFOAM. If not, see <http://www.gnu.org/licenses/>.
Class
Foam::compressible::LESModels::dynOneEqEddy
Foam::compressible::LESModels::homogeneousDynOneEqEddy
Description
One Equation Eddy Viscosity Model for compressible flows.
@ -46,12 +46,12 @@ Description
\endverbatim
SourceFiles
dynOneEqEddy.C
homogeneousDynOneEqEddy.C
\*---------------------------------------------------------------------------*/
#ifndef compressibleDynOneEqEddy_H
#define compressibleDynOneEqEddy_H
#ifndef compressibleHomogeneousDynOneEqEddy_H
#define compressibleHomogeneousDynOneEqEddy_H
#include "GenEddyVisc.H"
#include "LESfilter.H"
@ -66,10 +66,10 @@ namespace LESModels
{
/*---------------------------------------------------------------------------*\
Class dynOneEqEddy Declaration
Class homogeneousDynOneEqEddy Declaration
\*---------------------------------------------------------------------------*/
class dynOneEqEddy
class homogeneousDynOneEqEddy
:
public GenEddyVisc
{
@ -91,20 +91,20 @@ class dynOneEqEddy
dimensionedScalar ce_(const volSymmTensorField& D) const;
// Disallow default bitwise copy construct and assignment
dynOneEqEddy(const dynOneEqEddy&);
dynOneEqEddy& operator=(const dynOneEqEddy&);
homogeneousDynOneEqEddy(const homogeneousDynOneEqEddy&);
homogeneousDynOneEqEddy& operator=(const homogeneousDynOneEqEddy&);
public:
//- Runtime type information
TypeName("dynOneEqEddy");
TypeName("homogeneousDynOneEqEddy");
// Constructors
//- Constructor from components
dynOneEqEddy
homogeneousDynOneEqEddy
(
const volScalarField& rho,
const volVectorField& U,
@ -116,7 +116,7 @@ public:
//- Destructor
virtual ~dynOneEqEddy()
virtual ~homogeneousDynOneEqEddy()
{}

2
src/turbulenceModels/incompressible/LES/Make/files
View File

@ -12,8 +12,8 @@ SpalartAllmarasIDDES/SpalartAllmarasIDDES.C
SpalartAllmarasIDDES/IDDESDelta/IDDESDelta.C
oneEqEddy/oneEqEddy.C
homogeneousDynOneEqEddy/homogeneousDynOneEqEddy.C
dynOneEqEddy/dynOneEqEddy.C
locDynOneEqEddy/locDynOneEqEddy.C
Smagorinsky/Smagorinsky.C
homogeneousDynSmagorinsky/homogeneousDynSmagorinsky.C
LRRDiffStress/LRRDiffStress.C

14
src/turbulenceModels/incompressible/LES/dynLagrangian/dynLagrangian.H
View File

@ -25,8 +25,8 @@ Class
Foam::incompressible::LESModels::dynLagrangian
Description
Lagrangian Two Equations Eddy Viscosity Model for incompressible
flows
Dynamic eddy-viscosity model with Lagrangian averaging for incompressible
flow
\verbatim
B = 2/3*k*I - 2*nuSgs*dev(D)
@ -57,9 +57,13 @@ Description
\endverbatim
Reference:
1. Charles Meneveau, Thomas Lund and William Cabot
"A Lagrangian dynamic subgrid-scale model of turbulence"
J. Fluid Mech (1996), vol 319, pp. 353-385
\verbatim
"A Lagrangian dynamic subgrid-scale model of turbulence"
Charles Meneveau,
Thomas Lund,
William Cabot,
J. Fluid Mech (1996), vol 319, pp. 353-385
\endverbatim
SourceFiles
dynLagrangian.C

96
src/turbulenceModels/incompressible/LES/dynOneEqEddy/dynOneEqEddy.C
View File

@ -42,68 +42,61 @@ addToRunTimeSelectionTable(LESModel, dynOneEqEddy, dictionary);
// * * * * * * * * * * * * * Private Member Functions * * * * * * * * * * * //
void dynOneEqEddy::updateSubGridScaleFields(const volSymmTensorField& D)
void dynOneEqEddy::updateSubGridScaleFields
(
const volSymmTensorField& D,
const volScalarField& KK
)
{
nuSgs_ = ck(D)*sqrt(k_)*delta();
nuSgs_ = ck(D, KK)*sqrt(k_)*delta();
nuSgs_.correctBoundaryConditions();
}
dimensionedScalar dynOneEqEddy::ck(const volSymmTensorField& D) const
volScalarField dynOneEqEddy::ck
(
const volSymmTensorField& D,
const volScalarField& KK
) const
{
tmp<volScalarField> KK = 0.5*(filter_(magSqr(U())) - magSqr(filter_(U())));
const volSymmTensorField LL
(
simpleFilter_(dev(filter_(sqr(U())) - (sqr(filter_(U())))))
);
const volSymmTensorField MM
(
delta()*(filter_(sqrt(k_)*D) - 2*sqrt(KK + filter_(k_))*filter_(D))
simpleFilter_(-2.0*delta()*pow(KK, 0.5)*filter_(D))
);
dimensionedScalar MMMM = average(magSqr(MM));
const volScalarField ck
(
simpleFilter_(0.5*(LL && MM))
/(
simpleFilter_(magSqr(MM))
+ dimensionedScalar("small", sqr(MM.dimensions()), VSMALL)
)
);
if (MMMM.value() > VSMALL)
{
tmp<volSymmTensorField> LL = dev(filter_(sqr(U())) - sqr(filter_(U())));
return average(LL && MM)/MMMM;
}
else
{
return 0.0;
}
tmp<volScalarField> tfld = 0.5*(mag(ck) + ck);
return tfld();
}
dimensionedScalar dynOneEqEddy::ce(const volSymmTensorField& D) const
volScalarField dynOneEqEddy::ce
(
const volSymmTensorField& D,
const volScalarField& KK
) const
{
const volScalarField KK
const volScalarField ce
(
0.5*(filter_(magSqr(U())) - magSqr(filter_(U())))
simpleFilter_(nuEff()*(filter_(magSqr(D)) - magSqr(filter_(D))))
/simpleFilter_(pow(KK, 1.5)/(2.0*delta()))
);
const volScalarField mm
(
pow(KK + filter_(k_), 1.5)/(2*delta()) - filter_(pow(k_, 1.5))/delta()
);
dimensionedScalar mmmm = average(magSqr(mm));
if (mmmm.value() > VSMALL)
{
tmp<volScalarField> ee =
(
2*delta()*ck(D)
* (
filter_(sqrt(k_)*magSqr(D))
- 2*sqrt(KK + filter_(k_))*magSqr(filter_(D))
)
);
return average(ee*mm)/mmmm;
}
else
{
return 0.0;
}
tmp<volScalarField> tfld = 0.5*(mag(ce) + ce);
return tfld();
}
@ -134,12 +127,14 @@ dynOneEqEddy::dynOneEqEddy
mesh_
),
simpleFilter_(U.mesh()),
filterPtr_(LESfilter::New(U.mesh(), coeffDict())),
filter_(filterPtr_())
{
bound(k_, kMin_);
updateSubGridScaleFields(symm(fvc::grad(U)));
const volScalarField KK(0.5*(filter_(magSqr(U)) - magSqr(filter_(U))));
updateSubGridScaleFields(symm(fvc::grad(U)), KK);
printCoeffs();
}
@ -147,14 +142,15 @@ dynOneEqEddy::dynOneEqEddy
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
void dynOneEqEddy::correct(const tmp<volTensorField>& tgradU)
void dynOneEqEddy::correct(const tmp<volTensorField>& gradU)
{
const volTensorField& gradU = tgradU();
GenEddyVisc::correct(gradU);
LESModel::correct(gradU);
const volSymmTensorField D(symm(gradU));
volScalarField KK(0.5*(filter_(magSqr(U())) - magSqr(filter_(U()))));
KK.max(dimensionedScalar("small", KK.dimensions(), SMALL));
const volScalarField P(2.0*nuSgs_*magSqr(D));
tmp<fvScalarMatrix> kEqn
@ -164,7 +160,7 @@ void dynOneEqEddy::correct(const tmp<volTensorField>& tgradU)
- fvm::laplacian(DkEff(), k_)
==
P
- fvm::Sp(ce(D)*sqrt(k_)/delta(), k_)
- fvm::Sp(ce(D, KK)*sqrt(k_)/delta(), k_)
);
kEqn().relax();
@ -172,7 +168,7 @@ void dynOneEqEddy::correct(const tmp<volTensorField>& tgradU)
bound(k_, kMin_);
updateSubGridScaleFields(D);
updateSubGridScaleFields(D, KK);
}

50
src/turbulenceModels/incompressible/LES/dynOneEqEddy/dynOneEqEddy.H
View File

@ -25,29 +25,36 @@ Class
Foam::incompressible::LESModels::dynOneEqEddy
Description
One Equation Eddy Viscosity Model for incompressible flows.
Localised Dynamic One Equation Eddy Viscosity Model for incompressible
flows
Eddy viscosity SGS model using a modeled balance equation to simulate
the behaviour of k.
Thus
the behaviour of k, hence
\verbatim
d/dt(k) + div(U*k) - div(nuSgs*grad(k))
=
-B*L - ce*k^3/2/delta
-B*L - ce*rho*k^3/2/delta
and
B = 2/3*k*I - 2*nuSgs*dev(D)
Beff = 2/3*k*I - 2*nuEff*dev(D)
where
D = symm(grad(U));
nuSgs = ck*sqrt(k)*delta
nuSgs = cD*delta^2*||D||
nuEff = nuSgs + nu
\endverbatim
A dynamic procedure is here applied to evaluate ck and ce
\verbatim
ck=<L.M>/<M.M>
and
ce=<e*m>/<m*m>
where
K = 0.5*(F(U.U) - F(U).F(U))
L = (F(U*U) - F(U)*F(U) - 0.33*K*I)
M = delta*(F(sqrt(k)*D) - 2*sqrt(K + filter(k))*F(D))
m = pow(K + F(k), 3.0/2.0)/(2*delta) - F(pow(k, 3.0/2.0))/delta
e = 2*delta*ck*(F(sqrt(k)*(D && D)) - 2*sqrt(K + F(k))*(F(D) && F(D)))/
\endverbatim
SourceFiles
dynOneEqEddy.C
@ -57,6 +64,7 @@ SourceFiles
#define dynOneEqEddy_H
#include "GenEddyVisc.H"
#include "simpleFilter.H"
#include "LESfilter.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
@ -80,6 +88,7 @@ class dynOneEqEddy
volScalarField k_;
simpleFilter simpleFilter_;
autoPtr<LESfilter> filterPtr_;
LESfilter& filter_;
@ -87,11 +96,24 @@ class dynOneEqEddy
// Private Member Functions
//- Update sub-grid scale fields
void updateSubGridScaleFields(const volSymmTensorField& D);
void updateSubGridScaleFields
(
const volSymmTensorField& D,
const volScalarField& KK
);
//- Calculate ck, ce by filtering the velocity field U.
dimensionedScalar ck(const volSymmTensorField& D) const;
dimensionedScalar ce(const volSymmTensorField& D) const;
volScalarField ck
(
const volSymmTensorField&,
const volScalarField&
) const;
volScalarField ce
(
const volSymmTensorField&,
const volScalarField&
) const;
// Disallow default bitwise copy construct and assignment
dynOneEqEddy(const dynOneEqEddy&);

106
src/turbulenceModels/incompressible/LES/locDynOneEqEddy/locDynOneEqEddy.C → src/turbulenceModels/incompressible/LES/homogeneousDynOneEqEddy/homogeneousDynOneEqEddy.C
View File

@ -23,7 +23,7 @@ License
\*---------------------------------------------------------------------------*/
#include "locDynOneEqEddy.H"
#include "homogeneousDynOneEqEddy.H"
#include "addToRunTimeSelectionTable.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
@ -37,72 +37,79 @@ namespace LESModels
// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
defineTypeNameAndDebug(locDynOneEqEddy, 0);
addToRunTimeSelectionTable(LESModel, locDynOneEqEddy, dictionary);
defineTypeNameAndDebug(homogeneousDynOneEqEddy, 0);
addToRunTimeSelectionTable(LESModel, homogeneousDynOneEqEddy, dictionary);
// * * * * * * * * * * * * * Private Member Functions * * * * * * * * * * * //
void locDynOneEqEddy::updateSubGridScaleFields
(
const volSymmTensorField& D,
const volScalarField& KK
)
void homogeneousDynOneEqEddy::updateSubGridScaleFields(const volSymmTensorField& D)
{
nuSgs_ = ck(D, KK)*sqrt(k_)*delta();
nuSgs_ = ck(D)*sqrt(k_)*delta();
nuSgs_.correctBoundaryConditions();
}
volScalarField locDynOneEqEddy::ck
(
const volSymmTensorField& D,
const volScalarField& KK
) const
dimensionedScalar homogeneousDynOneEqEddy::ck(const volSymmTensorField& D) const
{
const volSymmTensorField LL
(
simpleFilter_(dev(filter_(sqr(U())) - (sqr(filter_(U())))))
);
tmp<volScalarField> KK = 0.5*(filter_(magSqr(U())) - magSqr(filter_(U())));
const volSymmTensorField MM
(
simpleFilter_(-2.0*delta()*pow(KK, 0.5)*filter_(D))
delta()*(filter_(sqrt(k_)*D) - 2*sqrt(KK + filter_(k_))*filter_(D))
);
const volScalarField ck
(
simpleFilter_(0.5*(LL && MM))
/(
simpleFilter_(magSqr(MM))
+ dimensionedScalar("small", sqr(MM.dimensions()), VSMALL)
)
);
dimensionedScalar MMMM = average(magSqr(MM));
tmp<volScalarField> tfld = 0.5*(mag(ck) + ck);
return tfld();
if (MMMM.value() > VSMALL)
{
tmp<volSymmTensorField> LL = dev(filter_(sqr(U())) - sqr(filter_(U())));
return average(LL && MM)/MMMM;
}
else
{
return 0.0;
}
}
volScalarField locDynOneEqEddy::ce
(
const volSymmTensorField& D,
const volScalarField& KK
) const
dimensionedScalar homogeneousDynOneEqEddy::ce(const volSymmTensorField& D) const
{
const volScalarField ce
const volScalarField KK
(
simpleFilter_(nuEff()*(filter_(magSqr(D)) - magSqr(filter_(D))))
/simpleFilter_(pow(KK, 1.5)/(2.0*delta()))
0.5*(filter_(magSqr(U())) - magSqr(filter_(U())))
);
tmp<volScalarField> tfld = 0.5*(mag(ce) + ce);
return tfld();
const volScalarField mm
(
pow(KK + filter_(k_), 1.5)/(2*delta()) - filter_(pow(k_, 1.5))/delta()
);
dimensionedScalar mmmm = average(magSqr(mm));
if (mmmm.value() > VSMALL)
{
tmp<volScalarField> ee =
(
2*delta()*ck(D)
* (
filter_(sqrt(k_)*magSqr(D))
- 2*sqrt(KK + filter_(k_))*magSqr(filter_(D))
)
);
return average(ee*mm)/mmmm;
}
else
{
return 0.0;
}
}
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
locDynOneEqEddy::locDynOneEqEddy
homogeneousDynOneEqEddy::homogeneousDynOneEqEddy
(
const volVectorField& U,
const surfaceScalarField& phi,
@ -127,14 +134,12 @@ locDynOneEqEddy::locDynOneEqEddy
mesh_
),
simpleFilter_(U.mesh()),
filterPtr_(LESfilter::New(U.mesh(), coeffDict())),
filter_(filterPtr_())
{
bound(k_, kMin_);
const volScalarField KK(0.5*(filter_(magSqr(U)) - magSqr(filter_(U))));
updateSubGridScaleFields(symm(fvc::grad(U)), KK);
updateSubGridScaleFields(symm(fvc::grad(U)));
printCoeffs();
}
@ -142,15 +147,14 @@ locDynOneEqEddy::locDynOneEqEddy
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
void locDynOneEqEddy::correct(const tmp<volTensorField>& gradU)
void homogeneousDynOneEqEddy::correct(const tmp<volTensorField>& tgradU)
{
LESModel::correct(gradU);
const volTensorField& gradU = tgradU();
GenEddyVisc::correct(gradU);
const volSymmTensorField D(symm(gradU));
volScalarField KK(0.5*(filter_(magSqr(U())) - magSqr(filter_(U()))));
KK.max(dimensionedScalar("small", KK.dimensions(), SMALL));
const volScalarField P(2.0*nuSgs_*magSqr(D));
tmp<fvScalarMatrix> kEqn
@ -160,7 +164,7 @@ void locDynOneEqEddy::correct(const tmp<volTensorField>& gradU)
- fvm::laplacian(DkEff(), k_)
==
P
- fvm::Sp(ce(D, KK)*sqrt(k_)/delta(), k_)
- fvm::Sp(ce(D)*sqrt(k_)/delta(), k_)
);
kEqn().relax();
@ -168,11 +172,11 @@ void locDynOneEqEddy::correct(const tmp<volTensorField>& gradU)
bound(k_, kMin_);
updateSubGridScaleFields(D, KK);
updateSubGridScaleFields(D);
}
bool locDynOneEqEddy::read()
bool homogeneousDynOneEqEddy::read()
{
if (GenEddyVisc::read())
{

72
src/turbulenceModels/incompressible/LES/locDynOneEqEddy/locDynOneEqEddy.H → src/turbulenceModels/incompressible/LES/homogeneousDynOneEqEddy/homogeneousDynOneEqEddy.H
View File

@ -22,49 +22,41 @@ License
along with OpenFOAM. If not, see <http://www.gnu.org/licenses/>.
Class
Foam::incompressible::LESModels::locDynOneEqEddy
Foam::incompressible::LESModels::homogeneousDynOneEqEddy
Description
Localised Dynamic One Equation Eddy Viscosity Model for incompressible
flows
One Equation Eddy Viscosity Model for incompressible flows.
Eddy viscosity SGS model using a modeled balance equation to simulate
the behaviour of k, hence
the behaviour of k.
Thus
\verbatim
d/dt(k) + div(U*k) - div(nuSgs*grad(k))
=
-B*L - ce*rho*k^3/2/delta
-B*L - ce*k^3/2/delta
and
B = 2/3*k*I - 2*nuSgs*dev(D)
Beff = 2/3*k*I - 2*nuEff*dev(D)
where
nuSgs = cD*delta^2*||D||
D = symm(grad(U));
nuSgs = ck*sqrt(k)*delta
nuEff = nuSgs + nu
\endverbatim
A dynamic procedure is here applied to evaluate ck and ce
\verbatim
ck=<L.M>/<M.M>
and
ce=<e*m>/<m*m>
where
K = 0.5*(F(U.U) - F(U).F(U))
L = (F(U*U) - F(U)*F(U) - 0.33*K*I)
M = delta*(F(sqrt(k)*D) - 2*sqrt(K + filter(k))*F(D))
m = pow(K + F(k), 3.0/2.0)/(2*delta) - F(pow(k, 3.0/2.0))/delta
e = 2*delta*ck*(F(sqrt(k)*(D && D)) - 2*sqrt(K + F(k))*(F(D) && F(D)))/
\endverbatim
SourceFiles
locDynOneEqEddy.C
homogeneousDynOneEqEddy.C
\*---------------------------------------------------------------------------*/
#ifndef locDynOneEqEddy_H
#define locDynOneEqEddy_H
#ifndef homogeneousDynOneEqEddy_H
#define homogeneousDynOneEqEddy_H
#include "GenEddyVisc.H"
#include "simpleFilter.H"
#include "LESfilter.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
@ -77,10 +69,10 @@ namespace LESModels
{
/*---------------------------------------------------------------------------*\
Class locDynOneEqEddy Declaration
Class homogeneousDynOneEqEddy Declaration
\*---------------------------------------------------------------------------*/
class locDynOneEqEddy
class homogeneousDynOneEqEddy
:
public GenEddyVisc
{
@ -88,7 +80,6 @@ class locDynOneEqEddy
volScalarField k_;
simpleFilter simpleFilter_;
autoPtr<LESfilter> filterPtr_;
LESfilter& filter_;
@ -96,39 +87,26 @@ class locDynOneEqEddy
// Private Member Functions
//- Update sub-grid scale fields
void updateSubGridScaleFields
(
const volSymmTensorField& D,
const volScalarField& KK
);
void updateSubGridScaleFields(const volSymmTensorField& D);
//- Calculate ck, ce by filtering the velocity field U.
volScalarField ck
(
const volSymmTensorField&,
const volScalarField&
) const;
volScalarField ce
(
const volSymmTensorField&,
const volScalarField&
) const;
dimensionedScalar ck(const volSymmTensorField& D) const;
dimensionedScalar ce(const volSymmTensorField& D) const;
// Disallow default bitwise copy construct and assignment
locDynOneEqEddy(const locDynOneEqEddy&);
locDynOneEqEddy& operator=(const locDynOneEqEddy&);
homogeneousDynOneEqEddy(const homogeneousDynOneEqEddy&);
homogeneousDynOneEqEddy& operator=(const homogeneousDynOneEqEddy&);
public:
//- Runtime type information
TypeName("locDynOneEqEddy");
TypeName("homogeneousDynOneEqEddy");
// Constructors
//- Construct from components
locDynOneEqEddy
homogeneousDynOneEqEddy
(
const volVectorField& U,
const surfaceScalarField& phi,
@ -139,7 +117,7 @@ public:
//- Destructor
virtual ~locDynOneEqEddy()
virtual ~homogeneousDynOneEqEddy()
{}