void dynamicKEqn<BasicTurbulenceModel>::correctNut()
{
const volScalarField KK
(
0.5*(filter_(magSqr(this->U_)) - magSqr(filter_(this->U_)))
);
correctNut(symm(fvc::grad(this->U_)), KK);
}
void dynamicKEqn<BasicTurbulenceModel>::correct()
{
if (!this->turbulence_)
{
return;
}
// Local references
const alphaField& alpha = this->alpha_;
const rhoField& rho = this->rho_;
const surfaceScalarField& alphaRhoPhi = this->alphaRhoPhi_;
const volVectorField& U = this->U_;
volScalarField& nut = this->nut_;
fv::options& fvOptions(fv::options::New(this->mesh_));
LESeddyViscosity<BasicTurbulenceModel>::correct();
volScalarField divU(fvc::div(fvc::absolute(this->phi(), U)));
tmp<volTensorField> tgradU(fvc::grad(U));
const volSymmTensorField D(dev(symm(tgradU())));
const volScalarField G(this->GName(), 2.0*nut*(tgradU() && D));
tgradU.clear();
volScalarField KK(0.5*(filter_(magSqr(U)) - magSqr(filter_(U))));
KK.max(dimensionedScalar("small", KK.dimensions(), SMALL));
tmp<fvScalarMatrix> kEqn
(
fvm::ddt(alpha, rho, k_)
+ fvm::div(alphaRhoPhi, k_)
- fvm::laplacian(alpha*rho*DkEff(), k_)
==
alpha*rho*G
- fvm::SuSp((2.0/3.0)*alpha*rho*divU, k_)
- fvm::Sp(Ce(D, KK)*alpha*rho*sqrt(k_)/this->delta(), k_)
+ kSource()
+ fvOptions(alpha, rho, k_)
);
kEqn.ref().relax();
fvOptions.constrain(kEqn.ref());
solve(kEqn);
fvOptions.correct(k_);
bound(k_, this->kMin_);
correctNut(D, KK);
}
void DeardorffDiffStress<BasicTurbulenceModel>::correct()
{
if (!this->turbulence_)
{
return;
}
// Local references
const alphaField& alpha = this->alpha_;
const rhoField& rho = this->rho_;
const surfaceScalarField& alphaRhoPhi = this->alphaRhoPhi_;
const volVectorField& U = this->U_;
volSymmTensorField& R = this->R_;
fv::options& fvOptions(fv::options::New(this->mesh_));
ReynoldsStress<LESModel<BasicTurbulenceModel>>::correct();
tmp<volTensorField> tgradU(fvc::grad(U));
const volTensorField& gradU = tgradU();
volSymmTensorField D(symm(gradU));
volSymmTensorField P(-twoSymm(R & gradU));
volScalarField k(this->k());
tmp<fvSymmTensorMatrix> REqn
(
fvm::ddt(alpha, rho, R)
+ fvm::div(alphaRhoPhi, R)
- fvm::laplacian(I*this->nu() + Cs_*(k/this->epsilon())*R, R)
+ fvm::Sp(Cm_*alpha*rho*sqrt(k)/this->delta(), R)
==
alpha*rho*P
+ (4.0/5.0)*alpha*rho*k*D
- ((2.0/3.0)*(1.0 - Cm_/this->Ce_)*I)*(alpha*rho*this->epsilon())
+ fvOptions(alpha, rho, R)
);
REqn.ref().relax();
fvOptions.constrain(REqn.ref());
REqn.ref().solve();
fvOptions.correct(R);
this->boundNormalStress(R);
correctNut();
}
SmagorinskyZhang<BasicTurbulenceModel>::SmagorinskyZhang
(
const alphaField& alpha,
const rhoField& rho,
const volVectorField& U,
const surfaceScalarField& alphaPhi,
const surfaceScalarField& phi,
const transportModel& transport,
const word& propertiesName,
const word& type
)
:
Smagorinsky<BasicTurbulenceModel>
(
alpha,
rho,
U,
alphaPhi,
phi,
transport,
propertiesName,
type
),
gasTurbulencePtr_(NULL),
Cmub_
(
dimensioned<scalar>::lookupOrAddToDict
(
"Cmub",
this->coeffDict_,
0.6
)
)
{
if (type == typeName)
{
correctNut();
this->printCoeffs(type);
}
}
Smagorinsky<BasicTurbulenceModel>::Smagorinsky
(
const alphaField& alpha,
const rhoField& rho,
const volVectorField& U,
const surfaceScalarField& alphaPhi,
const surfaceScalarField& phi,
const transportModel& transport,
const word& propertiesName,
const word& type
)
:
LESeddyViscosity<BasicTurbulenceModel>
(
type,
alpha,
rho,
U,
alphaPhi,
phi,
transport,
propertiesName
),
Ck_
(
dimensioned<scalar>::lookupOrAddToDict
(
"Ck",
this->coeffDict_,
0.094
)
)
{
if (type == typeName)
{
correctNut();
this->printCoeffs(type);
}
}
RNGkEpsilon<BasicTurbulenceModel>::RNGkEpsilon
(
const alphaField& alpha,
const rhoField& rho,
const volVectorField& U,
const surfaceScalarField& alphaRhoPhi,
const surfaceScalarField& phi,
const transportModel& transport,
const word& propertiesName,
const word& type
)
:
eddyViscosity<RASModel<BasicTurbulenceModel> >
(
type,
alpha,
rho,
U,
alphaRhoPhi,
phi,
transport,
propertiesName
),
Cmu_
(
dimensioned<scalar>::lookupOrAddToDict
(
"Cmu",
this->coeffDict_,
0.0845
)
),
C1_
(
dimensioned<scalar>::lookupOrAddToDict
(
"C1",
this->coeffDict_,
1.42
)
),
C2_
(
dimensioned<scalar>::lookupOrAddToDict
(
"C2",
this->coeffDict_,
1.68
)
),
C3_
(
dimensioned<scalar>::lookupOrAddToDict
(
"C3",
this->coeffDict_,
-0.33
)
),
sigmak_
(
dimensioned<scalar>::lookupOrAddToDict
(
"sigmak",
this->coeffDict_,
0.71942
)
),
sigmaEps_
(
dimensioned<scalar>::lookupOrAddToDict
(
"sigmaEps",
this->coeffDict_,
0.71942
)
),
eta0_
(
dimensioned<scalar>::lookupOrAddToDict
(
"eta0",
this->coeffDict_,
4.38
)
),
beta_
(
dimensioned<scalar>::lookupOrAddToDict
(
"beta",
this->coeffDict_,
0.012
)
),
k_
(
IOobject
(
IOobject::groupName("k", U.group()),
this->runTime_.timeName(),
this->mesh_,
IOobject::MUST_READ,
IOobject::AUTO_WRITE
),
this->mesh_
),
epsilon_
(
IOobject
(
IOobject::groupName("epsilon", U.group()),
this->runTime_.timeName(),
this->mesh_,
IOobject::MUST_READ,
IOobject::AUTO_WRITE
),
this->mesh_
)
{
bound(k_, this->kMin_);
bound(epsilon_, this->epsilonMin_);
if (type == typeName)
{
correctNut();
this->printCoeffs(type);
}
}
void RNGkEpsilon<BasicTurbulenceModel>::correct()
{
if (!this->turbulence_)
{
return;
}
// Local references
const alphaField& alpha = this->alpha_;
const rhoField& rho = this->rho_;
const surfaceScalarField& alphaRhoPhi = this->alphaRhoPhi_;
const volVectorField& U = this->U_;
volScalarField& nut = this->nut_;
eddyViscosity<RASModel<BasicTurbulenceModel> >::correct();
volScalarField divU(fvc::div(fvc::absolute(this->phi(), U)));
tmp<volTensorField> tgradU = fvc::grad(U);
volScalarField S2((tgradU() && dev(twoSymm(tgradU()))));
tgradU.clear();
volScalarField G(this->GName(), nut*S2);
volScalarField eta(sqrt(mag(S2))*k_/epsilon_);
volScalarField eta3(eta*sqr(eta));
volScalarField R
(
((eta*(-eta/eta0_ + scalar(1)))/(beta_*eta3 + scalar(1)))
);
// Update epsilon and G at the wall
epsilon_.boundaryField().updateCoeffs();
// Dissipation equation
tmp<fvScalarMatrix> epsEqn
(
fvm::ddt(alpha, rho, epsilon_)
+ fvm::div(alphaRhoPhi, epsilon_)
- fvm::laplacian(alpha*rho*DepsilonEff(), epsilon_)
==
(C1_ - R)*alpha*rho*G*epsilon_/k_
- fvm::SuSp(((2.0/3.0)*C1_ + C3_)*alpha*rho*divU, epsilon_)
- fvm::Sp(C2_*alpha*rho*epsilon_/k_, epsilon_)
+ epsilonSource()
);
epsEqn().relax();
epsEqn().boundaryManipulate(epsilon_.boundaryField());
solve(epsEqn);
bound(epsilon_, this->epsilonMin_);
// Turbulent kinetic energy equation
tmp<fvScalarMatrix> kEqn
(
fvm::ddt(alpha, rho, k_)
+ fvm::div(alphaRhoPhi, k_)
- fvm::laplacian(alpha*rho*DkEff(), k_)
==
alpha*rho*G
- fvm::SuSp((2.0/3.0)*alpha*rho*divU, k_)
- fvm::Sp(alpha*rho*epsilon_/k_, k_)
+ kSource()
);
kEqn().relax();
solve(kEqn);
bound(k_, this->kMin_);
correctNut();
}
SSG<BasicTurbulenceModel>::SSG
(
const alphaField& alpha,
const rhoField& rho,
const volVectorField& U,
const surfaceScalarField& alphaRhoPhi,
const surfaceScalarField& phi,
const transportModel& transport,
const word& propertiesName,
const word& type
)
:
ReynoldsStress<RASModel<BasicTurbulenceModel> >
(
type,
alpha,
rho,
U,
alphaRhoPhi,
phi,
transport,
propertiesName
),
Cmu_
(
dimensioned<scalar>::lookupOrAddToDict
(
"Cmu",
this->coeffDict_,
0.09
)
),
C1_
(
dimensioned<scalar>::lookupOrAddToDict
(
"C1",
this->coeffDict_,
3.4
)
),
C1s_
(
dimensioned<scalar>::lookupOrAddToDict
(
"C1s",
this->coeffDict_,
1.8
)
),
C2_
(
dimensioned<scalar>::lookupOrAddToDict
(
"C2",
this->coeffDict_,
4.2
)
),
C3_
(
dimensioned<scalar>::lookupOrAddToDict
(
"C3",
this->coeffDict_,
0.8
)
),
C3s_
(
dimensioned<scalar>::lookupOrAddToDict
(
"C3s",
this->coeffDict_,
1.3
)
),
C4_
(
dimensioned<scalar>::lookupOrAddToDict
(
"C4",
this->coeffDict_,
1.25
)
),
C5_
(
dimensioned<scalar>::lookupOrAddToDict
(
"C5",
this->coeffDict_,
0.4
)
),
Ceps1_
(
dimensioned<scalar>::lookupOrAddToDict
(
"Ceps1",
this->coeffDict_,
1.44
)
),
Ceps2_
(
dimensioned<scalar>::lookupOrAddToDict
(
"Ceps2",
this->coeffDict_,
1.92
)
),
Cs_
(
dimensioned<scalar>::lookupOrAddToDict
(
"Cs",
this->coeffDict_,
0.25
)
),
Ceps_
(
dimensioned<scalar>::lookupOrAddToDict
(
"Ceps",
this->coeffDict_,
0.15
)
),
k_
(
IOobject
(
"k",
this->runTime_.timeName(),
this->mesh_,
IOobject::NO_READ,
IOobject::AUTO_WRITE
),
0.5*tr(this->R_)
),
epsilon_
(
IOobject
(
"epsilon",
this->runTime_.timeName(),
this->mesh_,
IOobject::MUST_READ,
IOobject::AUTO_WRITE
),
this->mesh_
)
{
if (type == typeName)
{
this->printCoeffs(type);
this->boundNormalStress(this->R_);
bound(epsilon_, this->epsilonMin_);
k_ = 0.5*tr(this->R_);
// Correct nut for single-phase solvers only.
// For multiphase solvers the phase construction is not complete
// at this point.
if (isType<geometricOneField>(alpha))
{
correctNut();
}
}
}
LaheyKEpsilon<BasicTurbulenceModel>::LaheyKEpsilon
(
const alphaField& alpha,
const rhoField& rho,
const volVectorField& U,
const surfaceScalarField& alphaPhi,
const surfaceScalarField& phi,
const transportModel& transport,
const word& propertiesName,
const word& type
)
:
kEpsilon<BasicTurbulenceModel>
(
alpha,
rho,
U,
alphaPhi,
phi,
transport,
propertiesName,
type
),
gasTurbulencePtr_(NULL),
alphaInversion_
(
dimensioned<scalar>::lookupOrAddToDict
(
"alphaInversion",
this->coeffDict_,
0.3
)
),
Cp_
(
dimensioned<scalar>::lookupOrAddToDict
(
"Cp",
this->coeffDict_,
0.25
)
),
C3_
(
dimensioned<scalar>::lookupOrAddToDict
(
"C3",
this->coeffDict_,
this->C2_.value()
)
),
Cmub_
(
dimensioned<scalar>::lookupOrAddToDict
(
"Cmub",
this->coeffDict_,
0.6
)
)
{
if (type == typeName)
{
correctNut();
this->printCoeffs(type);
}
}
dynamicLagrangian<BasicTurbulenceModel>::dynamicLagrangian
(
const alphaField& alpha,
const rhoField& rho,
const volVectorField& U,
const surfaceScalarField& alphaRhoPhi,
const surfaceScalarField& phi,
const transportModel& transport,
const word& propertiesName,
const word& type
)
:
LESeddyViscosity<BasicTurbulenceModel>
(
type,
alpha,
rho,
U,
alphaRhoPhi,
phi,
transport,
propertiesName
),
flm_
(
IOobject
(
IOobject::groupName("flm", this->U_.group()),
this->runTime_.timeName(),
this->mesh_,
IOobject::MUST_READ,
IOobject::AUTO_WRITE
),
this->mesh_
),
fmm_
(
IOobject
(
IOobject::groupName("fmm", this->U_.group()),
this->runTime_.timeName(),
this->mesh_,
IOobject::MUST_READ,
IOobject::AUTO_WRITE
),
this->mesh_
),
theta_
(
dimensioned<scalar>::lookupOrAddToDict
(
"theta",
this->coeffDict_,
1.5
)
),
simpleFilter_(U.mesh()),
filterPtr_(LESfilter::New(U.mesh(), this->coeffDict())),
filter_(filterPtr_()),
flm0_("flm0", flm_.dimensions(), 0.0),
fmm0_("fmm0", fmm_.dimensions(), VSMALL)
{
if (type == typeName)
{
this->printCoeffs(type);
// Correct nut for single-phase solvers only.
// For multiphase solvers the phase construction is not complete
// at this point.
if (isType<geometricOneField>(alpha))
{
correctNut();
}
}
}
void dynamicLagrangian<BasicTurbulenceModel>::correctNut()
{
correctNut(fvc::grad(this->U_));
}
void dynamicLagrangian<BasicTurbulenceModel>::correct()
{
if (!this->turbulence_)
{
return;
}
// Local references
const surfaceScalarField& phi = this->phi_;
const volVectorField& U = this->U_;
LESeddyViscosity<BasicTurbulenceModel>::correct();
tmp<volTensorField> tgradU(fvc::grad(U));
const volTensorField& gradU = tgradU();
volSymmTensorField S(dev(symm(gradU)));
volScalarField magS(mag(S));
volVectorField Uf(filter_(U));
volSymmTensorField Sf(dev(symm(fvc::grad(Uf))));
volScalarField magSf(mag(Sf));
volSymmTensorField L(dev(filter_(sqr(U)) - (sqr(filter_(U)))));
volSymmTensorField M
(
2.0*sqr(this->delta())*(filter_(magS*S) - 4.0*magSf*Sf)
);
volScalarField invT
(
(1.0/(theta_.value()*this->delta()))*pow(flm_*fmm_, 1.0/8.0)
);
volScalarField LM(L && M);
fvScalarMatrix flmEqn
(
fvm::ddt(flm_)
+ fvm::div(phi, flm_)
==
invT*LM
- fvm::Sp(invT, flm_)
);
flmEqn.relax();
flmEqn.solve();
bound(flm_, flm0_);
volScalarField MM(M && M);
fvScalarMatrix fmmEqn
(
fvm::ddt(fmm_)
+ fvm::div(phi, fmm_)
==
invT*MM
- fvm::Sp(invT, fmm_)
);
fmmEqn.relax();
fmmEqn.solve();
bound(fmm_, fmm0_);
correctNut(gradU);
}
DeardorffDiffStress<BasicTurbulenceModel>::DeardorffDiffStress
(
const alphaField& alpha,
const rhoField& rho,
const volVectorField& U,
const surfaceScalarField& alphaRhoPhi,
const surfaceScalarField& phi,
const transportModel& transport,
const word& propertiesName,
const word& type
)
:
ReynoldsStress<LESModel<BasicTurbulenceModel> >
(
type,
alpha,
rho,
U,
alphaRhoPhi,
phi,
transport,
propertiesName
),
Ck_
(
dimensioned<scalar>::lookupOrAddToDict
(
"Ck",
this->coeffDict_,
0.094
)
),
Cm_
(
dimensioned<scalar>::lookupOrAddToDict
(
"Cm",
this->coeffDict_,
4.13
)
),
Ce_
(
dimensioned<scalar>::lookupOrAddToDict
(
"Ce",
this->coeffDict_,
1.05
)
),
Cs_
(
dimensioned<scalar>::lookupOrAddToDict
(
"Cs",
this->coeffDict_,
0.25
)
)
{
if (type == typeName)
{
this->printCoeffs(type);
this->boundNormalStress(this->R_);
// Correct nut for single-phase solvers only.
// For multiphase solvers the phase construction is not complete
// at this point.
if (isType<geometricOneField>(alpha))
{
correctNut();
}
}
}
void WALE<BasicTurbulenceModel>::correct()
{
LESeddyViscosity<BasicTurbulenceModel>::correct();
correctNut();
}
void v2f<BasicTurbulenceModel>::correct()
{
if (!this->turbulence_)
{
return;
}
// Local references
const alphaField& alpha = this->alpha_;
const rhoField& rho = this->rho_;
const surfaceScalarField& alphaRhoPhi = this->alphaRhoPhi_;
const volVectorField& U = this->U_;
volScalarField& nut = this->nut_;
fv::options& fvOptions(fv::options::New(this->mesh_));
eddyViscosity<RASModel<BasicTurbulenceModel>>::correct();
volScalarField divU(fvc::div(fvc::absolute(this->phi(), U)));
// Use N=6 so that f=0 at walls
const dimensionedScalar N("N", dimless, 6.0);
const volTensorField gradU(fvc::grad(U));
const volScalarField S2(2*magSqr(dev(symm(gradU))));
const volScalarField G(this->GName(), nut*S2);
const volScalarField Ts(this->Ts());
const volScalarField L2(type() + ":L2", sqr(Ls()));
const volScalarField v2fAlpha
(
type() + ":alpha",
1.0/Ts*((C1_ - N)*v2_ - 2.0/3.0*k_*(C1_ - 1.0))
);
const volScalarField Ceps1
(
"Ceps1",
1.4*(1.0 + 0.05*min(sqrt(k_/v2_), scalar(100.0)))
);
// Update epsilon (and possibly G) at the wall
epsilon_.boundaryFieldRef().updateCoeffs();
// Dissipation equation
tmp<fvScalarMatrix> epsEqn
(
fvm::ddt(alpha, rho, epsilon_)
+ fvm::div(alphaRhoPhi, epsilon_)
- fvm::laplacian(alpha*rho*DepsilonEff(), epsilon_)
==
Ceps1*alpha*rho*G/Ts
- fvm::SuSp(((2.0/3.0)*Ceps1 + Ceps3_)*alpha*rho*divU, epsilon_)
- fvm::Sp(Ceps2_*alpha*rho/Ts, epsilon_)
+ fvOptions(alpha, rho, epsilon_)
);
epsEqn.ref().relax();
fvOptions.constrain(epsEqn.ref());
epsEqn.ref().boundaryManipulate(epsilon_.boundaryFieldRef());
solve(epsEqn);
fvOptions.correct(epsilon_);
bound(epsilon_, this->epsilonMin_);
// Turbulent kinetic energy equation
tmp<fvScalarMatrix> kEqn
(
fvm::ddt(alpha, rho, k_)
+ fvm::div(alphaRhoPhi, k_)
- fvm::laplacian(alpha*rho*DkEff(), k_)
==
alpha*rho*G
- fvm::SuSp((2.0/3.0)*alpha*rho*divU, k_)
- fvm::Sp(alpha*rho*epsilon_/k_, k_)
+ fvOptions(alpha, rho, k_)
);
kEqn.ref().relax();
fvOptions.constrain(kEqn.ref());
solve(kEqn);
fvOptions.correct(k_);
bound(k_, this->kMin_);
// Relaxation function equation
tmp<fvScalarMatrix> fEqn
(
- fvm::laplacian(f_)
==
- fvm::Sp(1.0/L2, f_)
- 1.0/L2/k_*(v2fAlpha - C2_*G)
);
fEqn.ref().relax();
fvOptions.constrain(fEqn.ref());
solve(fEqn);
fvOptions.correct(f_);
bound(f_, fMin_);
// Turbulence stress normal to streamlines equation
tmp<fvScalarMatrix> v2Eqn
(
fvm::ddt(alpha, rho, v2_)
+ fvm::div(alphaRhoPhi, v2_)
- fvm::laplacian(alpha*rho*DkEff(), v2_)
==
alpha*rho*min(k_*f_, C2_*G - v2fAlpha)
- fvm::Sp(N*alpha*rho*epsilon_/k_, v2_)
+ fvOptions(alpha, rho, v2_)
);
v2Eqn.ref().relax();
fvOptions.constrain(v2Eqn.ref());
solve(v2Eqn);
fvOptions.correct(v2_);
bound(v2_, v2Min_);
correctNut();
}
LRR<BasicTurbulenceModel>::LRR
(
const alphaField& alpha,
const rhoField& rho,
const volVectorField& U,
const surfaceScalarField& alphaRhoPhi,
const surfaceScalarField& phi,
const transportModel& transport,
const word& propertiesName,
const word& type
)
:
ReynoldsStress<RASModel<BasicTurbulenceModel> >
(
type,
alpha,
rho,
U,
alphaRhoPhi,
phi,
transport,
propertiesName
),
Cmu_
(
dimensioned<scalar>::lookupOrAddToDict
(
"Cmu",
this->coeffDict_,
0.09
)
),
C1_
(
dimensioned<scalar>::lookupOrAddToDict
(
"C1",
this->coeffDict_,
1.8
)
),
C2_
(
dimensioned<scalar>::lookupOrAddToDict
(
"C2",
this->coeffDict_,
0.6
)
),
Ceps1_
(
dimensioned<scalar>::lookupOrAddToDict
(
"Ceps1",
this->coeffDict_,
1.44
)
),
Ceps2_
(
dimensioned<scalar>::lookupOrAddToDict
(
"Ceps2",
this->coeffDict_,
1.92
)
),
Cs_
(
dimensioned<scalar>::lookupOrAddToDict
(
"Cs",
this->coeffDict_,
0.25
)
),
Ceps_
(
dimensioned<scalar>::lookupOrAddToDict
(
"Ceps",
this->coeffDict_,
0.15
)
),
wallReflection_
(
Switch::lookupOrAddToDict
(
"wallReflection",
this->coeffDict_,
true
)
),
kappa_
(
dimensioned<scalar>::lookupOrAddToDict
(
"kappa",
this->coeffDict_,
0.41
)
),
Cref1_
(
dimensioned<scalar>::lookupOrAddToDict
(
"Cref1",
this->coeffDict_,
0.5
)
),
Cref2_
(
dimensioned<scalar>::lookupOrAddToDict
(
"Cref2",
this->coeffDict_,
0.3
)
),
k_
(
IOobject
(
"k",
this->runTime_.timeName(),
this->mesh_,
IOobject::NO_READ,
IOobject::AUTO_WRITE
),
0.5*tr(this->R_)
),
epsilon_
(
IOobject
(
"epsilon",
this->runTime_.timeName(),
this->mesh_,
IOobject::MUST_READ,
IOobject::AUTO_WRITE
),
this->mesh_
)
{
if (type == typeName)
{
this->boundNormalStress(this->R_);
bound(epsilon_, this->epsilonMin_);
k_ = 0.5*tr(this->R_);
correctNut();
this->printCoeffs(type);
}
}
void Smagorinsky<BasicTurbulenceModel>::correct()
{
LESeddyViscosity<BasicTurbulenceModel>::correct();
correctNut();
}