void lowReOneEqEddy::correct(const tmp<volTensorField>& tgradU)
{
const volTensorField& gradU = tgradU();
GenEddyVisc::correct(gradU);
volScalarField divU(fvc::div(phi()/fvc::interpolate(rho())));
volScalarField G(2*muSgs_*(gradU && dev(symm(gradU))));
tmp<fvScalarMatrix> kEqn
(
fvm::ddt(rho(), k_)
+ fvm::div(phi(), k_)
- fvm::laplacian(DkEff(), k_)
==
G
- fvm::SuSp(2.0/3.0*rho()*divU, k_)
- fvm::Sp(ce_*rho()*sqrt(k_)/delta(), k_)
);
kEqn().relax();
kEqn().solve();
bound(k_, kMin_);
updateSubGridScaleFields();
}
void dynOneEqEddy::correct(const tmp<volTensorField>& 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
(
fvm::ddt(k_)
+ fvm::div(phi(), k_)
- fvm::laplacian(DkEff(), k_)
==
P
- fvm::Sp(ce(D, KK)*sqrt(k_)/delta(), k_)
);
kEqn().relax();
kEqn().solve();
bound(k_, kMin_);
updateSubGridScaleFields(D, KK);
}
void kEpsilonSources::correct()
{
RASModel::correct();
if (!turbulence_)
{
return;
}
volScalarField G(GName(), nut_*2*magSqr(symm(fvc::grad(U_))));
// Update epsilon and G at the wall
epsilon_.boundaryField().updateCoeffs();
// Dissipation equation
tmp<fvScalarMatrix> epsEqn
(
fvm::ddt(epsilon_)
+ fvm::div(phi_, epsilon_)
- fvm::laplacian(DepsilonEff(), epsilon_)
==
C1_*G*epsilon_/k_
- fvm::Sp(C2_*epsilon_/k_, epsilon_)
+ fvOptions(epsilon_)
);
epsEqn().relax();
fvOptions.constrain(epsEqn());
epsEqn().boundaryManipulate(epsilon_.boundaryField());
solve(epsEqn);
fvOptions.correct(epsilon_);
bound(epsilon_, epsilonMin_);
// Turbulent kinetic energy equation
tmp<fvScalarMatrix> kEqn
(
fvm::ddt(k_)
+ fvm::div(phi_, k_)
- fvm::laplacian(DkEff(), k_)
==
G
- fvm::Sp(epsilon_/k_, k_)
+ fvOptions(k_)
);
kEqn().relax();
fvOptions.constrain(kEqn());
solve(kEqn);
fvOptions.correct(k_);
bound(k_, kMin_);
// Re-calculate viscosity
nut_ = Cmu_*sqr(k_)/epsilon_;
nut_.correctBoundaryConditions();
}
void kOmega::correct()
{
RASModel::correct();
if (!turbulence_)
{
return;
}
volScalarField G("RASModel::G", nut_*2*magSqr(symm(fvc::grad(U_))));
// Update omega and G at the wall
omega_.boundaryField().updateCoeffs();
// Turbulence specific dissipation rate equation
tmp<fvScalarMatrix> omegaEqn
(
fvm::ddt(omega_)
+ fvm::div(phi_, omega_)
- fvm::Sp(fvc::div(phi_), omega_)
- fvm::laplacian(DomegaEff(), omega_)
==
alpha_*G*omega_/k_
- fvm::Sp(beta_*omega_, omega_)
);
omegaEqn().relax();
omegaEqn().boundaryManipulate(omega_.boundaryField());
solve(omegaEqn);
bound(omega_, omega0_);
// Turbulent kinetic energy equation
tmp<fvScalarMatrix> kEqn
(
fvm::ddt(k_)
+ fvm::div(phi_, k_)
- fvm::Sp(fvc::div(phi_), k_)
- fvm::laplacian(DkEff(), k_)
==
G
- fvm::Sp(Cmu_*omega_, k_)
);
kEqn().relax();
solve(kEqn);
bound(k_, k0_);
// Re-calculate viscosity
nut_ = k_/(omega_ + omegaSmall_);
nut_.correctBoundaryConditions();
}
void oneEqEddy::correct(const tmp<volTensorField>& gradU)
{
GenEddyVisc::correct(gradU);
volScalarField G(GName(), 2.0*nuSgs_*magSqr(symm(gradU)));
tmp<fvScalarMatrix> kEqn
(
fvm::ddt(k_)
+ fvm::div(phi(), k_)
- fvm::laplacian(DkEff(), k_)
==
G
- fvm::Sp(ce_*sqrt(k_)/delta(), k_)
);
kEqn().relax();
kEqn().solve();
bound(k_, kMin_);
updateSubGridScaleFields();
}
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 LaunderSharmaKE::correct()
{
// Bound in case of topological change
// HJ, 22/Aug/2007
if (mesh_.changing())
{
bound(k_, k0_);
bound(epsilonTilda_, epsilon0_);
}
RASModel::correct();
if (!turbulence_)
{
return;
}
volScalarField S2 = 2*magSqr(symm(fvc::grad(U_)));
volScalarField G("RASModel::G", nut_*S2);
volScalarField E = 2.0*nu()*nut_*fvc::magSqrGradGrad(U_);
volScalarField D = 2.0*nu()*magSqr(fvc::grad(sqrt(k_)));
// Dissipation rate equation
tmp<fvScalarMatrix> epsEqn
(
fvm::ddt(epsilonTilda_)
+ fvm::div(phi_, epsilonTilda_)
+ fvm::SuSp(-fvc::div(phi_), epsilonTilda_)
- fvm::laplacian(DepsilonEff(), epsilonTilda_)
==
C1_*G*epsilonTilda_/k_
- fvm::Sp(C2_*f2()*epsilonTilda_/k_, epsilonTilda_)
+ E
);
epsEqn().relax();
solve(epsEqn);
bound(epsilonTilda_, epsilon0_);
// Turbulent kinetic energy equation
tmp<fvScalarMatrix> kEqn
(
fvm::ddt(k_)
+ fvm::div(phi_, k_)
+ fvm::SuSp(-fvc::div(phi_), k_)
- fvm::laplacian(DkEff(), k_)
==
G - fvm::Sp((epsilonTilda_ + D)/k_, k_)
);
kEqn().relax();
solve(kEqn);
bound(k_, k0_);
// Re-calculate viscosity
nut_ == Cmu_*fMu()*sqr(k_)/epsilonTilda_;
}
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();
}
void kEpsilon::correct()
{
// Bound in case of topological change
// HJ, 22/Aug/2007
if (mesh_.changing())
{
bound(k_, k0_);
bound(epsilon_, epsilon0_);
}
if (!turbulence_)
{
// Re-calculate viscosity
mut_ = rho_*Cmu_*sqr(k_)/(epsilon_ + epsilonSmall_);
mut_.correctBoundaryConditions();
// Re-calculate thermal diffusivity
alphat_ = mut_/Prt_;
alphat_.correctBoundaryConditions();
return;
}
RASModel::correct();
volScalarField divU = fvc::div(phi_/fvc::interpolate(rho_));
if (mesh_.moving())
{
divU += fvc::div(mesh_.phi());
}
tmp<volTensorField> tgradU = fvc::grad(U_);
volScalarField G("RASModel::G", mut_*(tgradU() && dev(twoSymm(tgradU()))));
tgradU.clear();
// Update epsilon and G at the wall
epsilon_.boundaryField().updateCoeffs();
// Dissipation equation
tmp<fvScalarMatrix> epsEqn
(
fvm::ddt(rho_, epsilon_)
+ fvm::div(phi_, epsilon_)
- fvm::laplacian(DepsilonEff(), epsilon_)
==
C1_*G*epsilon_/k_
- fvm::SuSp(((2.0/3.0)*C1_ + C3_)*rho_*divU, epsilon_)
- fvm::Sp(C2_*rho_*epsilon_/k_, epsilon_)
);
epsEqn().relax();
epsEqn().boundaryManipulate(epsilon_.boundaryField());
solve(epsEqn);
bound(epsilon_, epsilon0_);
// Turbulent kinetic energy equation
tmp<fvScalarMatrix> kEqn
(
fvm::ddt(rho_, k_)
+ fvm::div(phi_, k_)
- fvm::laplacian(DkEff(), k_)
==
G
- fvm::SuSp((2.0/3.0)*rho_*divU, k_)
- fvm::Sp(rho_*epsilon_/k_, k_)
);
kEqn().relax();
solve(kEqn);
bound(k_, k0_);
// Re-calculate viscosity
mut_ = rho_*Cmu_*sqr(k_)/epsilon_;
mut_.correctBoundaryConditions();
// Re-calculate thermal diffusivity
alphat_ = mut_/Prt_;
alphat_.correctBoundaryConditions();
}
void LienCubicKE::correct()
{
RASModel::correct();
if (!turbulence_)
{
return;
}
gradU_ = fvc::grad(U_);
// generation term
tmp<volScalarField> S2 = symm(gradU_) && gradU_;
volScalarField G
(
"RASModel::G",
Cmu_*sqr(k_)/epsilon_*S2 - (nonlinearStress_ && gradU_)
);
// Update epsilon and G at the wall
epsilon_.boundaryField().updateCoeffs();
// Dissipation equation
tmp<fvScalarMatrix> epsEqn
(
fvm::ddt(epsilon_)
+ fvm::div(phi_, epsilon_)
- fvm::laplacian(DepsilonEff(), epsilon_)
==
C1_*G*epsilon_/k_
- fvm::Sp(C2_*epsilon_/k_, epsilon_)
);
epsEqn().relax();
epsEqn().boundaryManipulate(epsilon_.boundaryField());
solve(epsEqn);
bound(epsilon_, epsilonMin_);
// Turbulent kinetic energy equation
tmp<fvScalarMatrix> kEqn
(
fvm::ddt(k_)
+ fvm::div(phi_, k_)
- fvm::laplacian(DkEff(), k_)
==
G
- fvm::Sp(epsilon_/k_, k_)
);
kEqn().relax();
solve(kEqn);
bound(k_, kMin_);
// Re-calculate viscosity
eta_ = k_/epsilon_*sqrt(2.0*magSqr(0.5*(gradU_ + gradU_.T())));
ksi_ = k_/epsilon_*sqrt(2.0*magSqr(0.5*(gradU_ - gradU_.T())));
Cmu_ = 2.0/(3.0*(A1_ + eta_ + alphaKsi_*ksi_));
fEta_ = A2_ + pow(eta_, 3.0);
C5viscosity_ =
- 2.0*pow(Cmu_, 3.0)*pow(k_, 4.0)/pow(epsilon_, 3.0)
*(magSqr(gradU_ + gradU_.T()) - magSqr(gradU_ - gradU_.T()));
nut_ = Cmu_*sqr(k_)/epsilon_ + C5viscosity_;
nut_.correctBoundaryConditions();
nonlinearStress_ = symm
(
// quadratic terms
pow(k_, 3.0)/sqr(epsilon_)*
(
Ctau1_/fEta_*
(
(gradU_ & gradU_)
+ (gradU_ & gradU_)().T()
)
+ Ctau2_/fEta_*(gradU_ & gradU_.T())
+ Ctau3_/fEta_*(gradU_.T() & gradU_)
)
// cubic term C4
- 20.0*pow(k_, 4.0)/pow(epsilon_, 3.0)
*pow(Cmu_, 3.0)
*(
((gradU_ & gradU_) & gradU_.T())
+ ((gradU_ & gradU_.T()) & gradU_.T())
- ((gradU_.T() & gradU_) & gradU_)
- ((gradU_.T() & gradU_.T()) & gradU_)
)
);
}
void PDRkEpsilon::correct()
{
if (!turbulence_)
{
// Re-calculate viscosity
mut_ = rho_*Cmu_*sqr(k_)/(epsilon_ + epsilonSmall_);
mut_.correctBoundaryConditions();
// Re-calculate thermal diffusivity
alphat_ = mut_/Prt_;
alphat_.correctBoundaryConditions();
return;
}
RASModel::correct();
volScalarField divU = fvc::div(phi_/fvc::interpolate(rho_));
if (mesh_.moving())
{
divU += fvc::div(mesh_.phi());
}
tmp<volTensorField> tgradU = fvc::grad(U_);
volScalarField G("RASModel::G", mut_*(tgradU() && dev(twoSymm(tgradU()))));
tgradU.clear();
// Update espsilon and G at the wall
epsilon_.boundaryField().updateCoeffs();
// Add the blockage generation term so that it is included consistently
// in both the k and epsilon equations
const volScalarField& betav = U_.db().lookupObject<volScalarField>("betav");
const PDRDragModel& drag =
U_.db().lookupObject<PDRDragModel>("PDRDragModel");
volScalarField GR = drag.Gk();
// Dissipation equation
tmp<fvScalarMatrix> epsEqn
(
betav*fvm::ddt(rho_, epsilon_)
+ fvm::div(phi_, epsilon_)
- fvm::laplacian(DepsilonEff(), epsilon_)
==
C1_*(betav*G + GR)*epsilon_/k_
- fvm::SuSp(((2.0/3.0)*C1_)*betav*rho_*divU, epsilon_)
- fvm::Sp(C2_*betav*rho_*epsilon_/k_, epsilon_)
);
epsEqn().relax();
epsEqn().boundaryManipulate(epsilon_.boundaryField());
solve(epsEqn);
bound(epsilon_, epsilon0_);
// Turbulent kinetic energy equation
tmp<fvScalarMatrix> kEqn
(
betav*fvm::ddt(rho_, k_)
+ fvm::div(phi_, k_)
- fvm::laplacian(DkEff(), k_)
==
betav*G + GR
- fvm::SuSp((2.0/3.0)*betav*rho_*divU, k_)
- fvm::Sp(betav*rho_*epsilon_/k_, k_)
);
kEqn().relax();
solve(kEqn);
bound(k_, k0_);
// Re-calculate viscosity
mut_ = rho_*Cmu_*sqr(k_)/epsilon_;
mut_.correctBoundaryConditions();
// Re-calculate thermal diffusivity
alphat_ = mut_/Prt_;
alphat_.correctBoundaryConditions();
}
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();
}
void realizableKE::correct()
{
// Bound in case of topological change
// HJ, 22/Aug/2007
if (mesh_.changing())
{
bound(k_, k0_);
bound(epsilon_, epsilon0_);
}
RASModel::correct();
if (!turbulence_)
{
return;
}
volTensorField gradU = fvc::grad(U_);
volScalarField S2 = 2*magSqr(dev(symm(gradU)));
volScalarField magS = sqrt(S2);
volScalarField eta = magS*k_/epsilon_;
volScalarField C1 = max(eta/(scalar(5) + eta), scalar(0.43));
volScalarField G("RASModel::G", nut_*S2);
// Update epsilon and G at the wall
epsilon_.boundaryField().updateCoeffs();
// Dissipation equation
tmp<fvScalarMatrix> epsEqn
(
fvm::ddt(epsilon_)
+ fvm::div(phi_, epsilon_)
+ fvm::SuSp(-fvc::div(phi_), epsilon_)
- fvm::laplacian(DepsilonEff(), epsilon_)
==
C1*magS*epsilon_
- fvm::Sp
(
C2_*epsilon_/(k_ + sqrt(nu()*epsilon_)),
epsilon_
)
);
epsEqn().relax();
epsEqn().boundaryManipulate(epsilon_.boundaryField());
solve(epsEqn);
bound(epsilon_, epsilon0_);
// Turbulent kinetic energy equation
tmp<fvScalarMatrix> kEqn
(
fvm::ddt(k_)
+ fvm::div(phi_, k_)
+ fvm::SuSp(-fvc::div(phi_), k_)
- fvm::laplacian(DkEff(), k_)
==
G - fvm::Sp(epsilon_/k_, k_)
);
kEqn().relax();
solve(kEqn);
bound(k_, k0_);
// Re-calculate viscosity
nut_ = rCmu(gradU, S2, magS)*sqr(k_)/epsilon_;
nut_.correctBoundaryConditions();
}
void realizableKE_Veh::correct()
{
RASModel::correct();
if (!turbulence_)
{
return;
}
const volTensorField gradU(fvc::grad(U_));
const volScalarField S2(2*magSqr(dev(symm(gradU))));
const volScalarField magS(sqrt(S2));
const volScalarField eta(magS*k_/epsilon_);
tmp<volScalarField> C1 = max(eta/(scalar(5) + eta), scalar(0.43));
volScalarField G("RASModel::G", nut_*S2);
//Estimating source terms for vehicle canopy
volVectorField Fi = 0.5*Cfcar_*VAD_*mag(U_-Ucar_)*(U_-Ucar_);
volScalarField Fk = (U_-Ucar_)&Fi;
volScalarField Fepsilon = epsilon_*sqrt(k_)*Cecar_/L_;
// Update epsilon and G at the wall
epsilon_.boundaryField().updateCoeffs();
// Dissipation equation
tmp<fvScalarMatrix> epsEqn
(
fvm::ddt(epsilon_)
+ fvm::div(phi_, epsilon_)
- fvm::Sp(fvc::div(phi_), epsilon_)
- fvm::laplacian(DepsilonEff(), epsilon_)
==
Fepsilon
+ C1*magS*epsilon_
- fvm::Sp
(
C2_*epsilon_/(k_ + sqrt(nu()*epsilon_)),
epsilon_
)
);
epsEqn().relax();
epsEqn().boundaryManipulate(epsilon_.boundaryField());
solve(epsEqn);
bound(epsilon_, epsilonMin_);
// Turbulent kinetic energy equation
tmp<fvScalarMatrix> kEqn
(
fvm::ddt(k_)
+ fvm::div(phi_, k_)
- fvm::Sp(fvc::div(phi_), k_)
- fvm::laplacian(DkEff(), k_)
==
Fk
+ G - fvm::Sp(epsilon_/k_, k_)
);
kEqn().relax();
solve(kEqn);
bound(k_, kMin_);
// Re-calculate viscosity
nut_ = rCmu(gradU, S2, magS)*sqr(k_)/epsilon_;
nut_.correctBoundaryConditions();
}
void PDRkEpsilon::correct()
{
if (!turbulence_)
{
// Re-calculate viscosity
nut_ = Cmu_*sqr(k_)/epsilon_;
nut_.correctBoundaryConditions();
// Re-calculate thermal diffusivity
//***HGWalphat_ = mut_/Prt_;
// alphat_.correctBoundaryConditions();
return;
}
RASModel::correct();
volScalarField divU(fvc::div(phi_/fvc::interpolate(rho_)));
if (mesh_.moving())
{
divU += fvc::div(mesh_.phi());
}
tmp<volTensorField> tgradU = fvc::grad(U_);
volScalarField G(GName(), rho_*nut_*(tgradU() && dev(twoSymm(tgradU()))));
tgradU.clear();
// Update espsilon and G at the wall
epsilon_.boundaryFieldRef().updateCoeffs();
// Add the blockage generation term so that it is included consistently
// in both the k and epsilon equations
const volScalarField& betav =
U_.db().lookupObject<volScalarField>("betav");
const volScalarField& Lobs =
U_.db().lookupObject<volScalarField>("Lobs");
const PDRDragModel& drag =
U_.db().lookupObject<PDRDragModel>("PDRDragModel");
volScalarField GR(drag.Gk());
volScalarField LI
(C4_*(Lobs + dimensionedScalar(dimLength, rootVSmall)));
// Dissipation equation
tmp<fvScalarMatrix> epsEqn
(
betav*fvm::ddt(rho_, epsilon_)
+ fvm::div(phi_, epsilon_)
- fvm::laplacian(rho_*DepsilonEff(), epsilon_)
==
C1_*betav*G*epsilon_/k_
+ 1.5*pow(Cmu_, 3.0/4.0)*GR*sqrt(k_)/LI
- fvm::SuSp(((2.0/3.0)*C1_)*betav*rho_*divU, epsilon_)
- fvm::Sp(C2_*betav*rho_*epsilon_/k_, epsilon_)
);
epsEqn.ref().relax();
epsEqn.ref().boundaryManipulate(epsilon_.boundaryFieldRef());
solve(epsEqn);
bound(epsilon_, epsilonMin_);
// Turbulent kinetic energy equation
tmp<fvScalarMatrix> kEqn
(
betav*fvm::ddt(rho_, k_)
+ fvm::div(phi_, k_)
- fvm::laplacian(rho_*DkEff(), k_)
==
betav*G + GR
- fvm::SuSp((2.0/3.0)*betav*rho_*divU, k_)
- fvm::Sp(betav*rho_*epsilon_/k_, k_)
);
kEqn.ref().relax();
solve(kEqn);
bound(k_, kMin_);
// Re-calculate viscosity
nut_ = Cmu_*sqr(k_)/epsilon_;
nut_.correctBoundaryConditions();
// Re-calculate thermal diffusivity
//***HGWalphat_ = mut_/Prt_;
// alphat_.correctBoundaryConditions();
}
void kEpsilon::correct()
{
// Bound in case of topological change
// HJ, 22/Aug/2007
if (mesh_.changing())
{
bound(k_, k0_);
bound(epsilon_, epsilon0_);
}
RASModel::correct();
if (!turbulence_)
{
return;
}
volScalarField G("RASModel::G", nut_*2*magSqr(symm(fvc::grad(U_))));
// Update epsilon and G at the wall
epsilon_.boundaryField().updateCoeffs();
// Dissipation equation
tmp<fvScalarMatrix> epsEqn
(
fvm::ddt(epsilon_)
+ fvm::div(phi_, epsilon_)
+ fvm::SuSp(-fvc::div(phi_), epsilon_)
- fvm::laplacian(DepsilonEff(), epsilon_)
==
C1_*G*epsilon_/k_
- fvm::Sp(C2_*epsilon_/k_, epsilon_)
);
epsEqn().relax();
epsEqn().boundaryManipulate(epsilon_.boundaryField());
solve(epsEqn);
bound(epsilon_, epsilon0_);
// Turbulent kinetic energy equation
tmp<fvScalarMatrix> kEqn
(
fvm::ddt(k_)
+ fvm::div(phi_, k_)
+ fvm::SuSp(-fvc::div(phi_), k_)
- fvm::laplacian(DkEff(), k_)
==
G
- fvm::Sp(epsilon_/k_, k_)
);
kEqn().relax();
solve(kEqn);
bound(k_, k0_);
// Re-calculate viscosity
nut_ = Cmu_*sqr(k_)/epsilon_;
nut_.correctBoundaryConditions();
}
void LaunderSharmaKE::correct()
{
// Bound in case of topological change
// HJ, 22/Aug/2007
if (mesh_.changing())
{
bound(k_, k0_);
bound(epsilon_, epsilon0_);
}
if (!turbulence_)
{
// Re-calculate viscosity
mut_ == rho_*Cmu_*fMu()*sqr(k_)/(epsilon_ + epsilonSmall_);
mut_ == min(mut_, muRatio()*mu());
// Re-calculate thermal diffusivity
alphat_ = mut_/Prt_;
alphat_.correctBoundaryConditions();
return;
}
RASModel::correct();
// Calculate parameters and coefficients for Launder-Sharma low-Reynolds
// number model
volScalarField E = 2.0*mu()*mut_*fvc::magSqrGradGrad(U_)/rho_;
volScalarField D = 2.0*mu()*magSqr(fvc::grad(sqrt(k_)))/rho_;
volScalarField divU = fvc::div(phi_/fvc::interpolate(rho_));
if (mesh_.moving())
{
divU += fvc::div(mesh_.phi());
}
tmp<volTensorField> tgradU = fvc::grad(U_);
volScalarField G("RASModel::G", mut_*(tgradU() && dev(twoSymm(tgradU()))));
tgradU.clear();
// Dissipation equation
tmp<fvScalarMatrix> epsEqn
(
fvm::ddt(rho_, epsilon_)
+ fvm::div(phi_, epsilon_)
- fvm::laplacian(DepsilonEff(), epsilon_)
==
C1_*G*epsilon_/k_ + fvm::SuSp((C3_ - 2.0/3.0*C1_)*rho_*divU, epsilon_)
- fvm::Sp(C2_*f2()*rho_*epsilon_/k_, epsilon_)
//+ 0.75*1.5*flameKproduction*epsilon_/k_
+ E
);
epsEqn().relax();
solve(epsEqn);
bound(epsilon_, epsilon0_);
// Turbulent kinetic energy equation
tmp<fvScalarMatrix> kEqn
(
fvm::ddt(rho_, k_)
+ fvm::div(phi_, k_)
- fvm::laplacian(DkEff(), k_)
==
G - fvm::SuSp(2.0/3.0*rho_*divU, k_)
- fvm::Sp(rho_*(epsilon_ + D)/k_, k_)
//+ flameKproduction
);
kEqn().relax();
solve(kEqn);
bound(k_, k0_);
// Re-calculate viscosity
mut_ == Cmu_*fMu()*rho_*sqr(k_)/(epsilon_ + epsilonSmall_);
mut_ == min(mut_, muRatio()*mu());
// Re-calculate thermal diffusivity
alphat_ = mut_/Prt_;
alphat_.correctBoundaryConditions();
}
void tatunRNG::correct()
{
if (!turbulence_)
{
// Re-calculate viscosity
mut_ = rho_*Cmu_*sqr(k_)/epsilon_;
mut_.correctBoundaryConditions();
// Re-calculate thermal diffusivity
alphat_ = mut_/Prt_;
alphat_.correctBoundaryConditions();
return;
}
RASModel::correct();
volScalarField divU(fvc::div(phi_/fvc::interpolate(rho_)));
if (mesh_.moving())
{
divU += fvc::div(mesh_.phi());
}
tmp<volTensorField> tgradU = fvc::grad(U_);
volScalarField S2((tgradU() && dev(twoSymm(tgradU()))));
tgradU.clear();
//volScalarField G(type() + ".G", mut_*S2);
volScalarField G(GName(), mut_*S2); // changed from 2.1.1 --> 2.2.2
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(rho_, epsilon_)
+ fvm::div(phi_, epsilon_)
- fvm::laplacian(DepsilonEff(), epsilon_)
==
(C1_ - R)*G*epsilon_/k_
- fvm::SuSp(((2.0/3.0)*C1_ + C3_)*rho_*divU, epsilon_)
- fvm::Sp(C2_*rho_*epsilon_/k_, epsilon_)
);
epsEqn().relax();
epsEqn().boundaryManipulate(epsilon_.boundaryField());
solve(epsEqn);
bound(epsilon_, epsilonMin_);
volScalarField YMperk = 2.0*rho_*epsilon_/(soundSpeed_*soundSpeed_);
// Turbulent kinetic energy equation
tmp<fvScalarMatrix> kEqn
(
fvm::ddt(rho_, k_)
+ fvm::div(phi_, k_)
- fvm::laplacian(DkEff(), k_)
==
G - fvm::SuSp(2.0/3.0*rho_*divU, k_)
- fvm::Sp(rho_*epsilon_/k_, k_)
- fvm::Sp(YMperk, k_)
);
kEqn().relax();
solve(kEqn);
bound(k_, kMin_);
// Re-calculate viscosity
mut_ = rho_*Cmu_*sqr(k_)/epsilon_;
mut_.correctBoundaryConditions();
// Re-calculate thermal diffusivity
alphat_ = mut_/Prt_;
alphat_.correctBoundaryConditions();
}
void gammaSST<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_;
volScalarField& omega_ = this->omega_;
volScalarField& k_ = this->k_;
eddyViscosity<RASModel<BasicTurbulenceModel> >::correct();
volScalarField divU(fvc::div(fvc::absolute(this->phi(), U)));
tmp<volTensorField> tgradU = fvc::grad(U);
const volScalarField S2(2*magSqr(symm(tgradU())));
const volScalarField S("S", sqrt(S2));
const volScalarField W("Omega", sqrt(2*magSqr(skew(tgradU()))));
volScalarField G(this->GName(), nut*S*W);
tgradU.clear();
// Update omega and G at the wall
omega_.boundaryFieldRef().updateCoeffs();
const volScalarField CDkOmega
( "CD",
(2*this->alphaOmega2_)*(fvc::grad(k_) & fvc::grad(omega_))/omega_
);
const volScalarField F1("F1", this->F1(CDkOmega));
{
volScalarField gamma(this->gamma(F1));
volScalarField beta(this->beta(F1));
// Turbulent frequency equation
tmp<fvScalarMatrix> omegaEqn
(
fvm::ddt(alpha, rho, omega_)
+ fvm::div(alphaRhoPhi, omega_)
- fvm::laplacian(alpha*rho*this->DomegaEff(F1), omega_)
==
alpha*rho*gamma*S*W
- fvm::Sp(alpha*rho*beta*omega_, omega_)
- fvm::SuSp
(
alpha*rho*(F1 - scalar(1))*CDkOmega/omega_,
omega_
)
);
omegaEqn.ref().relax();
omegaEqn.ref().boundaryManipulate(omega_.boundaryFieldRef());
solve(omegaEqn);
bound(omega_, this->omegaMin_);
}
// Turbulent kinetic energy equation
const volScalarField FonLim(
"FonLim",
min( max(sqr(this->y_)*S/this->nu() / (
2.2*ReThetacLim_) - 1., 0.), 3.)
);
const volScalarField PkLim(
"PkLim",
5*Ck_ * max(gammaInt()-0.2,0.) * (1-gammaInt()) * FonLim *
max(3*CSEP_*this->nu() - this->nut_, 0.*this->nut_) * S * W
);
tmp<fvScalarMatrix> kEqn
(
fvm::ddt(alpha, rho, k_)
+ fvm::div(alphaRhoPhi, k_)
- fvm::laplacian(alpha*rho*this->DkEff(F1), k_)
==
alpha*rho*(G*gammaInt() + PkLim)
- fvm::Sp(max(gammaInt(),scalar(0.1)) * alpha*rho*this->betaStar_*omega_, k_)
);
kEqn.ref().relax();
solve(kEqn);
bound(k_, this->kMin_);
this->correctNut(S2, this->F23());
// Intermittency equation (2)
volScalarField Pgamma1 = Flength_ * S * gammaInt_ * Fonset(S);
volScalarField Pgamma2 = ca2_ * W * gammaInt_ * Fturb();
tmp<fvScalarMatrix> gammaEqn
(
fvm::ddt(alpha, rho, gammaInt_)
+ fvm::div(alphaRhoPhi, gammaInt_)
- fvm::laplacian(alpha*rho*this->DgammaEff(), gammaInt_)
==
alpha*rho*Pgamma1 - fvm::Sp(alpha*rho*Pgamma1, gammaInt_) +
alpha*rho*Pgamma2 - fvm::Sp(alpha*rho*ce2_*Pgamma2, gammaInt_)
);
gammaEqn.ref().relax();
solve(gammaEqn);
bound(gammaInt_,scalar(0));
if (debug && this->runTime_.outputTime()) {
S.write();
W.write();
F1.write();
CDkOmega.write();
const volScalarField Pgamma("Pgamma", Pgamma1*(scalar(1)-gammaInt_));
Pgamma.write();
const volScalarField Egamma("Egamma", Pgamma2*(scalar(1)-ce2_*gammaInt_));
Egamma.write();
FonLim.write();
PkLim.write();
Fonset(S)().write();
FPG()().write();
}
}