void Foam::WhiteMetznerCross::correct()
{
// Velocity gradient tensor
volTensorField L = fvc::grad(U());
// Convected derivate term
volTensorField C = tau_ & L;
// Twice the rate of deformation tensor
volSymmTensorField twoD = twoSymm(L);
// Effective viscosity and relaxation time
volScalarField etaPValue = etaP_/
(1 + Foam::pow(K_* sqrt(2.0)*mag(symm(L)), (1 - m_)));
volScalarField lambdaValue = lambda_/
(1 + Foam::pow(L_ * sqrt(2.0)*mag(symm(L)), (1 - n_)));
// Stress transport equation
fvSymmTensorMatrix tauEqn
(
fvm::ddt(tau_)
+ fvm::div(phi(), tau_)
==
etaPValue/lambdaValue*twoD
+ twoSymm(C)
- fvm::Sp(1/lambdaValue, tau_)
);
tauEqn.relax();
tauEqn.solve();
}
void Foam::Lambda2::execute()
{
if (active_)
{
const fvMesh& mesh = refCast<const fvMesh>(obr_);
const volVectorField& U =
mesh.lookupObject<volVectorField>(UName_);
const volTensorField gradU(fvc::grad(U));
const volTensorField SSplusWW
(
(symm(gradU) & symm(gradU))
+ (skew(gradU) & skew(gradU))
);
volScalarField& Lambda2 =
const_cast<volScalarField&>
(
mesh.lookupObject<volScalarField>(type())
);
Lambda2 = -eigenValues(SSplusWW)().component(vector::Y);
}
}
void SolidSolver::calculateEpsilonSigma()
{
// - Green finite strain tensor
epsilon = symm( gradU ) + 0.5 * symm( gradU & gradU.T() );
// - second Piola-Kirchhoff stress tensor
sigma = 2 * mu * epsilon + lambda * ( I * tr( epsilon ) );
}
void dynLagrangianCsBound::correct(const tmp<volTensorField>& gradU)
{
LESModel::correct(gradU);
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(delta())*(filter_(magS*S) - 4.0*magSf*Sf));
volScalarField invT
(
(1.0/(theta_.value()*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_);
updateSubGridScaleFields(gradU);
}
tmp<volScalarField> realizableKE::rCmu
(
const volTensorField& gradU,
const volScalarField& S2,
const volScalarField& magS
)
{
tmp<volSymmTensorField> tS = dev(symm(gradU));
const volSymmTensorField& S = tS();
volScalarField W =
(2*sqrt(2.0))*((S&S)&&S)
/(
magS*S2
+ dimensionedScalar("small", dimensionSet(0, 0, -3, 0, 0), SMALL)
);
tS.clear();
volScalarField phis =
(1.0/3.0)*acos(min(max(sqrt(6.0)*W, -scalar(1)), scalar(1)));
volScalarField As = sqrt(6.0)*cos(phis);
volScalarField Us = sqrt(S2/2.0 + magSqr(skew(gradU)));
return 1.0/(A0_ + As*Us*k_/(epsilon_ + epsilonSmall_));
}
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>& tgradU)
{
const volTensorField& gradU = tgradU();
GenEddyVisc::correct(gradU);
volSymmTensorField D = dev(symm(gradU));
volScalarField divU = fvc::div(phi()/fvc::interpolate(rho()));
volScalarField G = 2*muSgs_*(gradU && D);
solve
(
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_(D)*rho()*sqrt(k_)/delta(), k_)
);
bound(k_, dimensionedScalar("0", k_.dimensions(), 1.0e-10));
updateSubGridScaleFields(D);
}
T Linalg<T, H>::symm(
const T &a, const T &b, const value_type &alpha, const value_type &beta,
Side side, Uplo uplo) {
T c(a.allocator());
symm(a, b, &c, alpha, beta, side, uplo);
return c;
}
void locDynOneEqEddy::correct(const tmp<volTensorField>& gradU)
{
LESModel::correct(gradU);
volSymmTensorField D = symm(gradU);
volScalarField KK = 0.5*(filter_(magSqr(U())) - magSqr(filter_(U())));
KK.max(dimensionedScalar("small", KK.dimensions(), SMALL));
volScalarField P = 2.0*nuSgs_*magSqr(D);
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_, k0());
updateSubGridScaleFields(D, KK);
}
void Foam::Giesekus::correct()
{
// Velocity gradient tensor
volTensorField L = fvc::grad(U());
// Convected derivate term
volTensorField C = tau_ & L;
// Twice the rate of deformation tensor
volSymmTensorField twoD = twoSymm(L);
// Stress transport equation
fvSymmTensorMatrix tauEqn
(
fvm::ddt(tau_)
+ fvm::div(phi(), tau_)
==
etaP_/lambda_*twoD
+ twoSymm(C)
- (alpha_/etaP_)*symm(tau_ & tau_)
- fvm::Sp(1/lambda_, tau_)
);
tauEqn.relax();
tauEqn.solve();
}
tmp<volSymmTensorField> WALE<BasicTurbulenceModel>::Sd
(
const volTensorField& gradU
) const
{
return dev(symm(gradU & gradU));
}
locDynOneEqEddy::locDynOneEqEddy
(
const volVectorField& U,
const surfaceScalarField& phi,
transportModel& transport
)
:
LESModel(typeName, U, phi, transport),
GenEddyVisc(U, phi, transport),
k_
(
IOobject
(
"k",
runTime_.timeName(),
U_.db(),
IOobject::MUST_READ,
IOobject::AUTO_WRITE
),
mesh_
),
simpleFilter_(U.mesh()),
filterPtr_(LESfilter::New(U.mesh(), coeffDict())),
filter_(filterPtr_())
{
volScalarField KK = 0.5*(filter_(magSqr(U)) - magSqr(filter_(U)));
updateSubGridScaleFields(symm(fvc::grad(U)), KK);
printCoeffs();
}
void dynamicLagrangian<BasicTurbulenceModel>::correctNut
(
const tmp<volTensorField>& gradU
)
{
this->nut_ = (flm_/fmm_)*sqr(this->delta())*mag(dev(symm(gradU)));
this->nut_.correctBoundaryConditions();
}
tmp<volScalarField> realizableKE::rCmu
(
const volTensorField& gradU
)
{
volScalarField S2 = 2*magSqr(dev(symm(gradU)));
volScalarField magS = sqrt(S2);
return rCmu(gradU, S2, magS);
}
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 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();
}
dimensionedSymmTensor symm(const dimensionedTensor& dt)
{
return dimensionedSymmTensor
(
"symm("+dt.name()+')',
dt.dimensions(),
symm(dt.value())
);
}
void bi::marginalise(const ExpGaussianPdf<V1, M1>& p1,
const ExpGaussianPdf<V2,M2>& p2, const M3 C,
const ExpGaussianPdf<V4, M4>& q2, ExpGaussianPdf<V5,M5>& p3) {
/* pre-conditions */
BI_ASSERT(q2.size() == p2.size());
BI_ASSERT(p3.size() == p1.size());
BI_ASSERT(C.size1() == p1.size() && C.size2() == p2.size());
typename sim_temp_vector<V1>::type z2(p2.size());
typename sim_temp_matrix<M1>::type K(p1.size(), p2.size());
typename sim_temp_matrix<M1>::type A1(p2.size(), p2.size());
typename sim_temp_matrix<M1>::type A2(p2.size(), p2.size());
/**
* Compute gain matrix:
*
* \f[\mathcal{K} = C_{\mathbf{x}_1,\mathbf{x}_2}\Sigma_2^{-1}\,.\f]
*/
symm(1.0, p2.prec(), C, 0.0, K, 'R', 'U');
/**
* Then result is given by \f$\mathcal{N}(\boldsymbol{\mu}',
* \Sigma')\f$, where:
*
* \f[\boldsymbol{\mu}' = \boldsymbol{\mu}_1 +
* \mathcal{K}(\boldsymbol{\mu}_3 - \boldsymbol{\mu}_2)\,,\f]
*/
z2 = q2.mean();
axpy(-1.0, p2.mean(), z2);
p3.mean() = p1.mean();
gemv(1.0, K, z2, 1.0, p3.mean());
/**
* and:
*
* \f{eqnarray*}
* \Sigma' &=& \Sigma_1 + \mathcal{K}(\Sigma_3 -
* \Sigma_2)\mathcal{K}^T \\
* &=& \Sigma_1 + \mathcal{K}\Sigma_3\mathcal{K}^T -
* \mathcal{K}\Sigma_2\mathcal{K}^T\,.
* \f}
*/
p3.cov() = p1.cov();
A1 = K;
trmm(1.0, q2.std(), A1, 'R', 'U', 'T');
syrk(1.0, A1, 1.0, p3.cov(), 'U');
A2 = K;
trmm(1.0, p2.std(), A2, 'R', 'U', 'T');
syrk(-1.0, A2, 1.0, p3.cov(), 'U');
/* make sure correct log-variables set */
p3.setLogs(p2.getLogs());
p3.init(); // redo precalculations
}
tmp<volScalarField> spectEddyVisc::k() const
{
volScalarField eps = 2*nuEff()*magSqr(symm(fvc::grad(U())));
return
cK1_*pow(delta()*eps, 2.0/3.0)
*exp(-cK2_*pow(delta(), -4.0/3.0)*nu()/pow(eps, 1.0/3.0))
- cK3_*sqrt(eps*nu())
*erfc(cK4_*pow(delta(), -2.0/3.0)*sqrt(nu())*pow(eps, -1.0/6.0));
}
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();
}
tmp<volScalarField> spectEddyVisc::k() const
{
const volScalarField eps(2*nuEff()*magSqr(symm(fvc::grad(U()))));
//TODO move this into a single kernel invocation
return
cK1_*pow(delta()*eps, 2.0/3.0)
*exp(-cK2_*pow(delta(), -4.0/3.0)*nu()/pow(eps, 1.0/3.0))
- cK3_*sqrt(eps*nu())
*erfc(cK4_*pow(delta(), -2.0/3.0)*sqrt(nu())*pow(eps, -1.0/6.0));
}
void Foam::S_MDCPP::correct()
{
// Velocity gradient tensor
volTensorField L = fvc::grad(U());
// Convected derivate term
volTensorField C = tau_ & L;
// Twice the rate of deformation tensor
volSymmTensorField twoD = twoSymm(L);
// Two phase transport properties treatment
volScalarField alpha1f = min(max(alpha(), scalar(0)), scalar(1));
volScalarField lambdaOb = alpha1f*lambdaOb1_ + (scalar(1) - alpha1f)*lambdaOb2_;
volScalarField lambdaOs = alpha1f*lambdaOs1_ + (scalar(1) - alpha1f)*lambdaOs2_;
volScalarField etaP = alpha1f*etaP1_ + (scalar(1) - alpha1f)*etaP2_;
volScalarField zeta = alpha1f*zeta1_ + (scalar(1) - alpha1f)*zeta2_;
volScalarField q = alpha1f*q1_ + (scalar(1) - alpha1f)*q2_;
// Lambda (Backbone stretch)
volScalarField Lambda =
Foam::sqrt(1 + tr(tau_)*lambdaOb*(1 - zeta)/3/etaP);
// Auxiliary field
volScalarField aux = Foam::exp( 2/q*(Lambda - 1));
// Extra function
volScalarField fTau =
aux*(2*lambdaOb/lambdaOs*(1 - 1/Lambda) + 1/Foam::sqr(Lambda));
// Stress transport equation
fvSymmTensorMatrix tauEqn
(
fvm::ddt(lambdaOb, tau_)
+ fvm::div(phi(), tau_)
==
etaP*twoD
+ lambdaOb * twoSymm(C)
- lambdaOb * zeta*symm(tau_ & twoD)
- fvm::Sp(fTau, tau_)
- (
(etaP/lambdaOb/(1 - zeta)*(fTau - aux)*I_)
)
);
tauEqn.relax();
tauEqn.solve();
}
volScalarField dynamicKEqn<BasicTurbulenceModel>::Ce() const
{
const volSymmTensorField D(dev(symm(fvc::grad(this->U_))));
volScalarField KK
(
0.5*(filter_(magSqr(this->U_)) - magSqr(filter_(this->U_)))
);
KK.max(dimensionedScalar("small", KK.dimensions(), SMALL));
return Ce(D, KK);
}
tmp<volScalarField> Smagorinsky<BasicTurbulenceModel>::k
(
const tmp<volTensorField>& gradU
) const
{
volSymmTensorField D(symm(gradU));
volScalarField a(this->Ce_/this->delta());
volScalarField b((2.0/3.0)*tr(D));
volScalarField c(2*Ck_*this->delta()*(dev(D) && D));
return sqr((-b + sqrt(sqr(b) + 4*a*c))/(2*a));
}
void dynLagrangianCsBound::updateSubGridScaleFields
(
const tmp<volTensorField>& gradU
)
{
Cs_ = Foam::sqrt(flm_/fmm_);
// Bound Cs
Cs_ = Foam::max(Cs_,CsMin);
Cs_ = Foam::min(Cs_,CsMax);
//nuSgs_ = Foam::sqr(Cs_)*delta()*sqrt(k(gradU));
nuSgs_ = Foam::sqr(Cs_)*sqr(delta())*sqrt(2.0*magSqr(dev(symm(gradU))));
nuSgs_.correctBoundaryConditions();
}
void Foam::XPP_DE::correct()
{
// Velocity gradient tensor
volTensorField L = fvc::grad(U());
// Convected derivate term
volTensorField C = S_ & L;
// Twice the rate of deformation tensor
volSymmTensorField twoD = twoSymm(L);
// Evolution of orientation
tmp<fvSymmTensorMatrix> SEqn
(
fvm::ddt(S_)
+ fvm::div(phi(), S_)
==
twoSymm(C)
- fvm::Sp((twoD && S_) , S_)
- fvm::Sp
(
1/lambdaOb_/Foam::sqr(Lambda_)*
(1 - alpha_ - 3*alpha_*Foam::pow(Lambda_, 4)*tr(S_ & S_)),
S_
)
- 1/lambdaOb_/Foam::sqr(Lambda_)*
(3*alpha_*Foam::pow(Lambda_, 4)*symm(S_ & S_) - (1 - alpha_)/3*I_)
);
SEqn().relax();
solve(SEqn);
// Evolution of the backbone stretch
fvScalarMatrix LambdaEqn
(
fvm::ddt(Lambda_)
+ fvm::div(phi(), Lambda_)
==
fvm::Sp((twoD && S_)/2 , Lambda_)
- fvm::Sp(Foam::exp( 2/q_*(Lambda_ - 1))/lambdaOs_ , Lambda_)
+ Foam::exp(2/q_*(Lambda_ - 1))/lambdaOs_
);
LambdaEqn.relax();
LambdaEqn.solve();
// Viscoelastic stress
tau_ = etaP_/lambdaOb_*(3*Foam::sqr(Lambda_)*S_ - I_);
}
void spectEddyVisc::updateSubGridScaleFields(const volTensorField& gradU)
{
volScalarField Re = sqr(delta())*mag(symm(gradU))/nu();
for (label i=0; i<5; i++)
{
nuSgs_ =
nu()
/(
scalar(1)
- exp(-cB_*pow(nu()/(nuSgs_ + nu()), 1.0/3.0)*pow(Re, -2.0/3.0))
);
}
nuSgs_.correctBoundaryConditions();
}
void Smagorinsky::updateSubGridScaleFields(const volTensorField& gradU)
{
volSymmTensorField D(symm(gradU));
volScalarField a(ce_/delta());
volScalarField b((2.0/3.0)*tr(D));
volScalarField c(2*ck_*delta()*(dev(D) && D));
volScalarField k(sqr((-b + sqrt(sqr(b) + 4*a*c))/(2*a)));
muSgs_ = ck_*rho()*delta()*sqrt(k);
muSgs_.correctBoundaryConditions();
alphaSgs_ = muSgs_/Prt_;
alphaSgs_.correctBoundaryConditions();
}
Eigen::MatrixXd unflattenSymmetric(Eigen::VectorXd flat)
{
//todo: other data types?
//todo: safety/size checking?
int num_rows = (-1 + sqrt(1 + 4 * 2 * flat.rows())) / 2; //solve for number of rows using quadratic eq
Eigen::MatrixXd symm(num_rows, num_rows);
int count = 0;
for (int i = 0; i < num_rows; i++) {
int ltcsz = num_rows - i;
symm.block(i, i, ltcsz, 1) = flat.block(count, 0, ltcsz, 1);
symm.block(i, i, 1, ltcsz) = flat.block(count, 0, ltcsz, 1).transpose();
count += ltcsz;
}
return symm;
}
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();
}
