Dynamic LES models: Rationalize naming

src/turbulenceModels/compressible/LES/Make/files

@@ -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
 

src/turbulenceModels/compressible/LES/homogeneousDynOneEqEddy/homogeneousDynOneEqEddy.C

@@ -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);
+defineTypeNameAndDebug(homogeneousDynOneEqEddy, 0);
-addToRunTimeSelectionTable(LESModel, dynOneEqEddy, dictionary);
+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())
     {

src/turbulenceModels/compressible/LES/homogeneousDynOneEqEddy/homogeneousDynOneEqEddy.H

@@ -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
+#ifndef compressibleHomogeneousDynOneEqEddy_H
-#define compressibleDynOneEqEddy_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&);
+        homogeneousDynOneEqEddy(const homogeneousDynOneEqEddy&);
-        dynOneEqEddy& operator=(const dynOneEqEddy&);
+        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()
     {}
 
 

src/turbulenceModels/incompressible/LES/Make/files

@@ -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

src/turbulenceModels/incompressible/LES/dynLagrangian/dynLagrangian.H

@@ -25,8 +25,8 @@ Class
     Foam::incompressible::LESModels::dynLagrangian
 
 Description
-    Lagrangian Two Equations Eddy Viscosity Model for incompressible
+    Dynamic eddy-viscosity model with Lagrangian averaging for incompressible
-    flows
+    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
+    \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

src/turbulenceModels/incompressible/LES/dynOneEqEddy/dynOneEqEddy.C

@@ -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
-
-    if (MMMM.value() > VSMALL)
-    {
-        tmp<volSymmTensorField> LL = dev(filter_(sqr(U())) - sqr(filter_(U())));
-
-        return average(LL && MM)/MMMM;
-    }
-    else
-    {
-        return 0.0;
-    }
-}
-
-
-dimensionedScalar dynOneEqEddy::ce(const volSymmTensorField& D) const
-{
-    const volScalarField KK
     (
-        0.5*(filter_(magSqr(U())) - magSqr(filter_(U())))
+        simpleFilter_(0.5*(LL && MM))
-    );
+       /(
-
+            simpleFilter_(magSqr(MM))
-    const volScalarField mm
+          + dimensionedScalar("small", sqr(MM.dimensions()), VSMALL)
-    (
-        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;
+    tmp<volScalarField> tfld = 0.5*(mag(ck) + ck);
-    }
+    return tfld();
-    else
+}
-    {
+
-        return 0.0;
+
-    }
+volScalarField dynOneEqEddy::ce
+(
+    const volSymmTensorField& D,
+    const volScalarField& KK
+) const
+{
+    const volScalarField ce
+    (
+        simpleFilter_(nuEff()*(filter_(magSqr(D)) - magSqr(filter_(D))))
+       /simpleFilter_(pow(KK, 1.5)/(2.0*delta()))
+    );
+
+    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();
+    LESModel::correct(gradU);
-
-    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
@@ -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);
 }
 
 

src/turbulenceModels/incompressible/LES/dynOneEqEddy/dynOneEqEddy.H

@@ -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.
+    the behaviour of k, hence
-
-    Thus
     \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
-
+        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
     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;
+        volScalarField ck
-        dimensionedScalar ce(const volSymmTensorField& D) const;
+        (
+            const volSymmTensorField&,
+            const volScalarField&
+        ) const;
+
+        volScalarField ce
+        (
+            const volSymmTensorField&,
+            const volScalarField&
+        ) const;
 
         // Disallow default bitwise copy construct and assignment
         dynOneEqEddy(const dynOneEqEddy&);

src/turbulenceModels/incompressible/LES/homogeneousDynOneEqEddy/homogeneousDynOneEqEddy.C

@@ -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);
+defineTypeNameAndDebug(homogeneousDynOneEqEddy, 0);
-addToRunTimeSelectionTable(LESModel, locDynOneEqEddy, dictionary);
+addToRunTimeSelectionTable(LESModel, homogeneousDynOneEqEddy, dictionary);
 
 // * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
 
-void locDynOneEqEddy::updateSubGridScaleFields
+void homogeneousDynOneEqEddy::updateSubGridScaleFields(const volSymmTensorField& D)
-(
-    const volSymmTensorField& D,
-    const volScalarField& KK
-)
 {
-    nuSgs_ = ck(D, KK)*sqrt(k_)*delta();
+    nuSgs_ = ck(D)*sqrt(k_)*delta();
     nuSgs_.correctBoundaryConditions();
 }
 
 
-volScalarField locDynOneEqEddy::ck
+dimensionedScalar homogeneousDynOneEqEddy::ck(const volSymmTensorField& D) const
-(
-    const volSymmTensorField& D,
-    const volScalarField& KK
-) const
 {
-    const volSymmTensorField LL
+    tmp<volScalarField> KK = 0.5*(filter_(magSqr(U())) - magSqr(filter_(U())));
-    (
-        simpleFilter_(dev(filter_(sqr(U())) - (sqr(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
+    dimensionedScalar MMMM = average(magSqr(MM));
-    (
-        simpleFilter_(0.5*(LL && MM))
-       /(
-            simpleFilter_(magSqr(MM))
-          + dimensionedScalar("small", sqr(MM.dimensions()), VSMALL)
-        )
-    );
 
-    tmp<volScalarField> tfld = 0.5*(mag(ck) + ck);
+    if (MMMM.value() > VSMALL)
-    return tfld();
+    {
+        tmp<volSymmTensorField> LL = dev(filter_(sqr(U())) - sqr(filter_(U())));
+
+        return average(LL && MM)/MMMM;
+    }
+    else
+    {
+        return 0.0;
+    }
 }
 
 
-volScalarField locDynOneEqEddy::ce
+dimensionedScalar homogeneousDynOneEqEddy::ce(const volSymmTensorField& D) const
-(
-    const volSymmTensorField& D,
-    const volScalarField& KK
-) const
 {
-    const volScalarField ce
+    const volScalarField KK
     (
-        simpleFilter_(nuEff()*(filter_(magSqr(D)) - magSqr(filter_(D))))
+        0.5*(filter_(magSqr(U())) - magSqr(filter_(U())))
-       /simpleFilter_(pow(KK, 1.5)/(2.0*delta()))
     );
 
-    tmp<volScalarField> tfld = 0.5*(mag(ce) + ce);
+    const volScalarField mm
-    return tfld();
+    (
+        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)));
-    updateSubGridScaleFields(symm(fvc::grad(U)), KK);
 
     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())
     {

src/turbulenceModels/incompressible/LES/homogeneousDynOneEqEddy/homogeneousDynOneEqEddy.H

@@ -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
+    One Equation Eddy Viscosity Model for incompressible flows.
-    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
+#ifndef homogeneousDynOneEqEddy_H
-#define locDynOneEqEddy_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
+        void updateSubGridScaleFields(const volSymmTensorField& D);
-        (
-            const volSymmTensorField& D,
-            const volScalarField& KK
-        );
 
         //- Calculate ck, ce by filtering the velocity field U.
-        volScalarField ck
+        dimensionedScalar ck(const volSymmTensorField& D) const;
-        (
+        dimensionedScalar ce(const volSymmTensorField& D) const;
-            const volSymmTensorField&,
-            const volScalarField&
-        ) const;
-
-        volScalarField ce
-        (
-            const volSymmTensorField&,
-            const volScalarField&
-        ) const;
 
         // Disallow default bitwise copy construct and assignment
-        locDynOneEqEddy(const locDynOneEqEddy&);
+        homogeneousDynOneEqEddy(const homogeneousDynOneEqEddy&);
-        locDynOneEqEddy& operator=(const locDynOneEqEddy&);
+        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()
     {}