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