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(); }