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 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 LRR<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_; ReynoldsStress<RASModel<BasicTurbulenceModel> >::correct(); tmp<volTensorField> tgradU(fvc::grad(U)); const volTensorField& gradU = tgradU(); volSymmTensorField P(-twoSymm(R & gradU)); volScalarField G(this->GName(), 0.5*mag(tr(P))); // 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_) == Ceps1_*alpha*rho*G*epsilon_/k_ - fvm::Sp(Ceps2_*alpha*rho*epsilon_/k_, epsilon_) ); epsEqn().relax(); epsEqn().boundaryManipulate(epsilon_.boundaryField()); solve(epsEqn); bound(epsilon_, this->epsilonMin_); // Correct the trace of the tensorial production to be consistent // with the near-wall generation from the wall-functions const fvPatchList& patches = this->mesh_.boundary(); forAll(patches, patchi) { const fvPatch& curPatch = patches[patchi]; if (isA<wallFvPatch>(curPatch)) { forAll(curPatch, facei) { label faceCelli = curPatch.faceCells()[facei]; P[faceCelli] *= min ( G[faceCelli]/(0.5*mag(tr(P[faceCelli])) + SMALL), 1.0 ); } } }
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 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 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 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 mixtureKEpsilon<BasicTurbulenceModel>::correct() { const transportModel& gas = this->transport(); const twoPhaseSystem& fluid = gas.fluid(); // Only solve the mixture turbulence for the gas-phase if (&gas != &fluid.phase1()) { // This is the liquid phase but check the model for the gas-phase // is consistent this->liquidTurbulence(); return; } if (!this->turbulence_) { return; } // Initialise the mixture fields if they have not yet been constructed initMixtureFields(); // Local references to gas-phase properties const surfaceScalarField& phig = this->phi_; const volVectorField& Ug = this->U_; const volScalarField& alphag = this->alpha_; volScalarField& kg = this->k_; volScalarField& epsilong = this->epsilon_; volScalarField& nutg = this->nut_; // Local references to liquid-phase properties mixtureKEpsilon<BasicTurbulenceModel>& liquidTurbulence = this->liquidTurbulence(); const surfaceScalarField& phil = liquidTurbulence.phi_; const volVectorField& Ul = liquidTurbulence.U_; const volScalarField& alphal = liquidTurbulence.alpha_; volScalarField& kl = liquidTurbulence.k_; volScalarField& epsilonl = liquidTurbulence.epsilon_; volScalarField& nutl = liquidTurbulence.nut_; // Local references to mixture properties volScalarField& rhom = rhom_(); volScalarField& km = km_(); volScalarField& epsilonm = epsilonm_(); eddyViscosity<RASModel<BasicTurbulenceModel> >::correct(); // Update the effective mixture density rhom = this->rhom(); // Mixture flux surfaceScalarField phim("phim", mixFlux(phil, phig)); // Mixture velocity divergence volScalarField divUm ( mixU ( fvc::div(fvc::absolute(phil, Ul)), fvc::div(fvc::absolute(phig, Ug)) ) ); tmp<volScalarField> Gc; { tmp<volTensorField> tgradUl = fvc::grad(Ul); Gc = tmp<volScalarField> ( new volScalarField ( this->GName(), nutl*(tgradUl() && dev(twoSymm(tgradUl()))) ) ); tgradUl.clear(); // Update k, epsilon and G at the wall kl.boundaryField().updateCoeffs(); epsilonl.boundaryField().updateCoeffs(); Gc().checkOut(); } tmp<volScalarField> Gd; { tmp<volTensorField> tgradUg = fvc::grad(Ug); Gd = tmp<volScalarField> ( new volScalarField ( this->GName(), nutg*(tgradUg() && dev(twoSymm(tgradUg()))) ) ); tgradUg.clear(); // Update k, epsilon and G at the wall kg.boundaryField().updateCoeffs(); epsilong.boundaryField().updateCoeffs(); Gd().checkOut(); } // Mixture turbulence generation volScalarField Gm(mix(Gc, Gd)); // Mixture turbulence viscosity volScalarField nutm(mixU(nutl, nutg)); // Update the mixture k and epsilon boundary conditions km == mix(kl, kg); bound(km, this->kMin_); epsilonm == mix(epsilonl, epsilong); bound(epsilonm, this->epsilonMin_); // Dissipation equation tmp<fvScalarMatrix> epsEqn ( fvm::ddt(rhom, epsilonm) + fvm::div(phim, epsilonm) - fvm::Sp(fvc::ddt(rhom) + fvc::div(phim), epsilonm) - fvm::laplacian(DepsilonEff(rhom*nutm), epsilonm) == C1_*rhom*Gm*epsilonm/km - fvm::SuSp(((2.0/3.0)*C1_)*rhom*divUm, epsilonm) - fvm::Sp(C2_*rhom*epsilonm/km, epsilonm) + epsilonSource() ); epsEqn().relax(); epsEqn().boundaryManipulate(epsilonm.boundaryField()); solve(epsEqn); bound(epsilonm, this->epsilonMin_); // Turbulent kinetic energy equation tmp<fvScalarMatrix> kmEqn ( fvm::ddt(rhom, km) + fvm::div(phim, km) - fvm::Sp(fvc::ddt(rhom) + fvc::div(phim), km) - fvm::laplacian(DkEff(rhom*nutm), km) == rhom*Gm - fvm::SuSp((2.0/3.0)*rhom*divUm, km) - fvm::Sp(rhom*epsilonm/km, km) + kSource() ); kmEqn().relax(); solve(kmEqn); bound(km, this->kMin_); km.correctBoundaryConditions(); volScalarField Cc2(rhom/(alphal*rholEff() + alphag*rhogEff()*Ct2_())); kl = Cc2*km; kl.correctBoundaryConditions(); epsilonl = Cc2*epsilonm; epsilonl.correctBoundaryConditions(); liquidTurbulence.correctNut(); Ct2_() = Ct2(); kg = Ct2_()*kl; kg.correctBoundaryConditions(); epsilong = Ct2_()*epsilonl; epsilong.correctBoundaryConditions(); nutg = Ct2_()*(liquidTurbulence.nu()/this->nu())*nutl; }
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 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_) ) ); }