void Foam::combustionModels::EDC<ReactionThermo>::correct()
{
tmp<volScalarField> tepsilon(this->turbulence().epsilon());
const volScalarField& epsilon = tepsilon();
tmp<volScalarField> tmu(this->turbulence().mu());
const volScalarField& mu = tmu();
tmp<volScalarField> tk(this->turbulence().k());
const volScalarField& k = tk();
tmp<volScalarField> trho(this->rho());
const volScalarField& rho = trho();
scalarField tauStar(epsilon.size(), 0);
if (version_ == EDCversions::v2016)
{
tmp<volScalarField> ttc(this->chemistryPtr_->tc());
const volScalarField& tc = ttc();
forAll(tauStar, i)
{
const scalar nu = mu[i]/(rho[i] + small);
const scalar Da =
max(min(sqrt(nu/(epsilon[i] + small))/tc[i], 10), 1e-10);
const scalar ReT = sqr(k[i])/(nu*epsilon[i] + small);
const scalar CtauI = min(C1_/(Da*sqrt(ReT + 1)), 2.1377);
const scalar CgammaI =
max(min(C2_*sqrt(Da*(ReT + 1)), 5), 0.4082);
const scalar gammaL =
CgammaI*pow025(nu*epsilon[i]/(sqr(k[i]) + small));
tauStar[i] = CtauI*sqrt(nu/(epsilon[i] + small));
if (gammaL >= 1)
{
kappa_[i] = 1;
}
else
{
kappa_[i] =
max
(
min
(
pow(gammaL, exp1_)/(1 - pow(gammaL, exp2_)),
1
),
0
);
}
}
}
void epsilonLowReWallFunctionFvPatchScalarField::calculate
(
const turbulenceModel& turbulence,
const List<scalar>& cornerWeights,
const fvPatch& patch,
scalarField& G,
scalarField& epsilon
)
{
const label patchi = patch.index();
const scalarField& y = turbulence.y()[patchi];
const scalar Cmu25 = pow025(Cmu_);
const scalar Cmu75 = pow(Cmu_, 0.75);
const tmp<volScalarField> tk = turbulence.k();
const volScalarField& k = tk();
const tmp<scalarField> tnuw = turbulence.nu(patchi);
const scalarField& nuw = tnuw();
const tmp<scalarField> tnutw = turbulence.nut(patchi);
const scalarField& nutw = tnutw();
const fvPatchVectorField& Uw = turbulence.U().boundaryField()[patchi];
const scalarField magGradUw(mag(Uw.snGrad()));
// Set epsilon and G
forAll(nutw, faceI)
{
label cellI = patch.faceCells()[faceI];
scalar yPlus = Cmu25*sqrt(k[cellI])*y[faceI]/nuw[faceI];
scalar w = cornerWeights[faceI];
if (yPlus > yPlusLam_)
{
epsilon[cellI] += w*Cmu75*pow(k[cellI], 1.5)/(kappa_*y[faceI]);
}
else
{
epsilon[cellI] += w*2.0*k[cellI]*nuw[faceI]/sqr(y[faceI]);
}
G[cellI] +=
w
*(nutw[faceI] + nuw[faceI])
*magGradUw[faceI]
*Cmu25*sqrt(k[cellI])
/(kappa_*y[faceI]);
}
void kLowReWallFunctionFvPatchScalarField::updateCoeffs()
{
if (updated())
{
return;
}
const label patchi = patch().index();
const turbulenceModel& turbModel = db().lookupObject<turbulenceModel>
(
IOobject::groupName
(
turbulenceModel::propertiesName,
internalField().group()
)
);
const scalarField& y = turbModel.y()[patchi];
const tmp<volScalarField> tk = turbModel.k();
const volScalarField& k = tk();
const tmp<scalarField> tnuw = turbModel.nu(patchi);
const scalarField& nuw = tnuw();
const scalar Cmu25 = pow025(Cmu_);
scalarField& kw = *this;
// Set k wall values
forAll(kw, facei)
{
label celli = patch().faceCells()[facei];
scalar uTau = Cmu25*sqrt(k[celli]);
scalar yPlus = uTau*y[facei]/nuw[facei];
if (yPlus > yPlusLam_)
{
scalar Ck = -0.416;
scalar Bk = 8.366;
kw[facei] = Ck/kappa_*log(yPlus) + Bk;
}
else
{
scalar C = 11.0;
scalar Cf = (1.0/sqr(yPlus + C) + 2.0*yPlus/pow3(C) - 1.0/sqr(C));
kw[facei] = 2400.0/sqr(Ceps2_)*Cf;
}
kw[facei] *= sqr(uTau);
}
void v2WallFunctionFvPatchScalarField::updateCoeffs()
{
if (updated())
{
return;
}
const label patchi = patch().index();
const turbulenceModel& turbModel = db().lookupObject<turbulenceModel>
(
IOobject::groupName
(
turbulenceModel::propertiesName,
internalField().group()
)
);
const scalarField& y = turbModel.y()[patchi];
const tmp<volScalarField> tk = turbModel.k();
const volScalarField& k = tk();
const tmp<scalarField> tnuw = turbModel.nu(patchi);
const scalarField& nuw = tnuw();
const scalar Cmu25 = pow025(Cmu_);
scalarField& v2 = *this;
// Set v2 wall values
forAll(v2, facei)
{
label celli = patch().faceCells()[facei];
scalar uTau = Cmu25*sqrt(k[celli]);
scalar yPlus = uTau*y[facei]/nuw[facei];
if (yPlus > yPlusLam_)
{
scalar Cv2 = 0.193;
scalar Bv2 = -0.94;
v2[facei] = Cv2/kappa_*log(yPlus) + Bv2;
}
else
{
scalar Cv2 = 0.193;
v2[facei] = Cv2*pow4(yPlus);
}
v2[facei] *= sqr(uTau);
}
tmp<fvScalarMatrix> kOmegaSSTSASnew<BasicTurbulenceModel>::Qsas
(
const volScalarField& S2
) const
{
volScalarField L
(
sqrt(this->k_)/(pow025(this->betaStar_)*this->omega_)
);
volScalarField Lvk
(
max
(
kappa_*sqrt(S2)
/(
mag(fvc::laplacian(this->U_))
+ dimensionedScalar
(
"ROOTVSMALL",
dimensionSet(0, -1, -1, 0, 0),
ROOTVSMALL
)
),
Cs_*delta()
)
);
return fvm::Su
(
this->alpha_*this->rho_
*min
(
max
(
zeta2_*kappa_*S2*sqr(L/Lvk)
- (2*C_/sigmaPhi_)*this->k_
*max
(
magSqr(fvc::grad(this->omega_))/sqr(this->omega_),
magSqr(fvc::grad(this->k_))/sqr(this->k_)
),
dimensionedScalar("0", dimensionSet(0, 0, -2, 0, 0), 0)
),
// Limit SAS production of omega for numerical stability,
// particularly during start-up
this->omega_/(0.1*this->omega_.time().deltaT())
),
this->omega_
);
}
tmp<scalarField> nutkWallFunctionFvPatchScalarField::yPlus() const
{
const label patchI = patch().index();
const RASModel& rasModel = db().lookupObject<RASModel>("RASProperties");
const scalarField& y = rasModel.y()[patchI];
const tmp<volScalarField> tk = rasModel.k();
const volScalarField& k = tk();
tmp<scalarField> kwc = k.boundaryField()[patchI].patchInternalField();
const scalarField& nuw = rasModel.nu()().boundaryField()[patchI];
return pow025(Cmu_)*y*sqrt(kwc)/nuw;
}
Foam::tmp<Foam::volScalarField> Foam::diameterModels::IATEsource::Ur() const
{
const uniformDimensionedVectorField& g =
phase().U().db().lookupObject<uniformDimensionedVectorField>("g");
return
sqrt(2.0)
*pow025
(
fluid().sigma()*mag(g)
*(otherPhase().rho() - phase().rho())
/sqr(otherPhase().rho())
)
*pow(max(1 - phase(), scalar(0)), 1.75);
}
tmp<scalarField> nutkWallFunctionFvPatchScalarField::yPlus() const
{
const label patchi = patch().index();
const turbulenceModel& turbModel = db().lookupObject<turbulenceModel>
(
IOobject::groupName
(
turbulenceModel::propertiesName,
dimensionedInternalField().group()
)
);
const scalarField& y = turbModel.y()[patchi];
const tmp<volScalarField> tk = turbModel.k();
const volScalarField& k = tk();
tmp<scalarField> kwc = k.boundaryField()[patchi].patchInternalField();
const tmp<scalarField> tnuw = turbModel.nu(patchi);
const scalarField& nuw = tnuw();
return pow025(Cmu_)*y*sqrt(kwc)/nuw;
}
void epsilonLowReWallFunctionFvPatchScalarField::calculate
(
const turbulenceModel& turbulence,
const gpuList<scalar>& cornerWeights,
const fvPatch& patch,
scalargpuField& G,
scalargpuField& epsilon
)
{
const label patchi = patch.index();
const scalargpuField& y = turbulence.y()[patchi];
const scalar Cmu25 = pow025(Cmu_);
const scalar Cmu75 = pow(Cmu_, 0.75);
const tmp<volScalarField> tk = turbulence.k();
const volScalarField& k = tk();
const tmp<scalargpuField> tnuw = turbulence.nu(patchi);
const scalargpuField& nuw = tnuw();
const tmp<scalargpuField> tnutw = turbulence.nut(patchi);
const scalargpuField& nutw = tnutw();
const fvPatchVectorField& Uw = turbulence.U().boundaryField()[patchi];
const scalargpuField magGradUw(mag(Uw.snGrad()));
matrixPatchOperation
(
patchi,
epsilon,
patch.boundaryMesh().mesh().lduAddr(),
EpsilonLowReCalculateEpsilonFunctor
(
yPlusLam_,
Cmu25,
Cmu75,
kappa_,
cornerWeights.data(),
y.data(),
k.getField().data(),
nuw.data()
)
);
matrixPatchOperation
(
patchi,
G,
patch.boundaryMesh().mesh().lduAddr(),
EpsilonLowReCalculateGFunctor
(
Cmu25,
kappa_,
cornerWeights.data(),
y.data(),
k.getField().data(),
nuw.data(),
nutw.data(),
magGradUw.data()
)
);
}
int main(int argc, char *argv[])
{
argList::addNote
(
"apply a simplified boundary-layer model to the velocity and\n"
"turbulence fields based on the 1/7th power-law."
);
argList::addOption
(
"ybl",
"scalar",
"specify the boundary-layer thickness"
);
argList::addOption
(
"Cbl",
"scalar",
"boundary-layer thickness as Cbl * mean distance to wall"
);
argList::addBoolOption
(
"writenut",
"write nut field"
);
#include "setRootCase.H"
if (!args.optionFound("ybl") && !args.optionFound("Cbl"))
{
FatalErrorIn(args.executable())
<< "Neither option 'ybl' or 'Cbl' have been provided to calculate "
<< "the boundary-layer thickness.\n"
<< "Please choose either 'ybl' OR 'Cbl'."
<< exit(FatalError);
}
else if (args.optionFound("ybl") && args.optionFound("Cbl"))
{
FatalErrorIn(args.executable())
<< "Both 'ybl' and 'Cbl' have been provided to calculate "
<< "the boundary-layer thickness.\n"
<< "Please choose either 'ybl' OR 'Cbl'."
<< exit(FatalError);
}
#include "createTime.H"
#include "createMesh.H"
#include "createFields.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
// Modify velocity by applying a 1/7th power law boundary-layer
// u/U0 = (y/ybl)^(1/7)
// assumes U0 is the same as the current cell velocity
Info<< "Setting boundary layer velocity" << nl << endl;
scalar yblv = ybl.value();
forAll(U, cellI)
{
if (y[cellI] <= yblv)
{
mask[cellI] = 1;
U[cellI] *= ::pow(y[cellI]/yblv, (1.0/7.0));
}
}
mask.correctBoundaryConditions();
Info<< "Writing U\n" << endl;
U.write();
// Update/re-write phi
#include "createPhi.H"
phi.write();
singlePhaseTransportModel laminarTransport(U, phi);
autoPtr<incompressible::turbulenceModel> turbulence
(
incompressible::turbulenceModel::New(U, phi, laminarTransport)
);
if (isA<incompressible::RASModel>(turbulence()))
{
// Calculate nut - reference nut is calculated by the turbulence model
// on its construction
tmp<volScalarField> tnut = turbulence->nut();
volScalarField& nut = tnut();
volScalarField S(mag(dev(symm(fvc::grad(U)))));
nut = (1 - mask)*nut + mask*sqr(kappa*min(y, ybl))*::sqrt(2)*S;
// do not correct BC - wall functions will 'undo' manipulation above
// by using nut from turbulence model
if (args.optionFound("writenut"))
{
Info<< "Writing nut" << endl;
nut.write();
}
//--- Read and modify turbulence fields
// Turbulence k
tmp<volScalarField> tk = turbulence->k();
volScalarField& k = tk();
scalar ck0 = pow025(Cmu)*kappa;
k = (1 - mask)*k + mask*sqr(nut/(ck0*min(y, ybl)));
// do not correct BC - operation may use inconsistent fields wrt these
// local manipulations
// k.correctBoundaryConditions();
Info<< "Writing k\n" << endl;
k.write();
// Turbulence epsilon
tmp<volScalarField> tepsilon = turbulence->epsilon();
volScalarField& epsilon = tepsilon();
scalar ce0 = ::pow(Cmu, 0.75)/kappa;
epsilon = (1 - mask)*epsilon + mask*ce0*k*sqrt(k)/min(y, ybl);
// do not correct BC - wall functions will use non-updated k from
// turbulence model
// epsilon.correctBoundaryConditions();
Info<< "Writing epsilon\n" << endl;
epsilon.write();
// Turbulence omega
IOobject omegaHeader
(
"omega",
runTime.timeName(),
mesh,
IOobject::MUST_READ,
IOobject::NO_WRITE,
false
);
if (omegaHeader.headerOk())
{
volScalarField omega(omegaHeader, mesh);
dimensionedScalar k0("VSMALL", k.dimensions(), VSMALL);
omega = (1 - mask)*omega + mask*epsilon/(Cmu*k + k0);
// do not correct BC - wall functions will use non-updated k from
// turbulence model
// omega.correctBoundaryConditions();
Info<< "Writing omega\n" << endl;
omega.write();
}
// Turbulence nuTilda
IOobject nuTildaHeader
(
"nuTilda",
runTime.timeName(),
mesh,
IOobject::MUST_READ,
IOobject::NO_WRITE,
false
);
if (nuTildaHeader.headerOk())
{
volScalarField nuTilda(nuTildaHeader, mesh);
nuTilda = nut;
// do not correct BC
// nuTilda.correctBoundaryConditions();
Info<< "Writing nuTilda\n" << endl;
nuTilda.write();
}
}
Info<< nl << "ExecutionTime = " << runTime.elapsedCpuTime() << " s"
<< " ClockTime = " << runTime.elapsedClockTime() << " s"
<< nl << endl;
Info<< "End\n" << endl;
return 0;
}
void Foam::WallLocalSpringSliderDashpot<CloudType>::evaluateWall
(
typename CloudType::parcelType& p,
const point& site,
const WallSiteData<vector>& data,
scalar pREff
) const
{
// wall patch index
label wPI = patchMap_[data.patchIndex()];
// data for this patch
scalar Estar = Estar_[wPI];
scalar Gstar = Gstar_[wPI];
scalar alpha = alpha_[wPI];
scalar b = b_[wPI];
scalar mu = mu_[wPI];
vector r_PW = p.position() - site;
vector U_PW = p.U() - data.wallData();
scalar normalOverlapMag = max(pREff - mag(r_PW), 0.0);
vector rHat_PW = r_PW/(mag(r_PW) + VSMALL);
scalar kN = (4.0/3.0)*sqrt(pREff)*Estar;
scalar etaN = alpha*sqrt(p.mass()*kN)*pow025(normalOverlapMag);
vector fN_PW =
rHat_PW
*(kN*pow(normalOverlapMag, b) - etaN*(U_PW & rHat_PW));
p.f() += fN_PW;
vector USlip_PW =
U_PW - (U_PW & rHat_PW)*rHat_PW
+ (p.omega() ^ (pREff*-rHat_PW));
scalar deltaT = this->owner().mesh().time().deltaTValue();
vector& tangentialOverlap_PW =
p.collisionRecords().matchWallRecord(-r_PW, pREff).collisionData();
tangentialOverlap_PW += USlip_PW*deltaT;
scalar tangentialOverlapMag = mag(tangentialOverlap_PW);
if (tangentialOverlapMag > VSMALL)
{
scalar kT = 8.0*sqrt(pREff*normalOverlapMag)*Gstar;
scalar etaT = etaN;
// Tangential force
vector fT_PW;
if (kT*tangentialOverlapMag > mu*mag(fN_PW))
{
// Tangential force greater than sliding friction,
// particle slips
fT_PW = -mu*mag(fN_PW)*USlip_PW/mag(USlip_PW);
tangentialOverlap_PW = vector::zero;
}
else
{
fT_PW =
-kT*tangentialOverlapMag
*tangentialOverlap_PW/tangentialOverlapMag
- etaT*USlip_PW;
}
p.f() += fT_PW;
p.torque() += (pREff*-rHat_PW) ^ fT_PW;
}
}
tmp<scalarField>
alphatPhaseChangeJayatillekeWallFunctionFvPatchScalarField::calcAlphat
(
const scalarField& prevAlphat
) const
{
// Lookup the fluid model
const phaseSystem& fluid =
db().lookupObject<phaseSystem>("phaseProperties");
const phaseModel& phase
(
fluid.phases()[internalField().group()]
);
const label patchi = patch().index();
// Retrieve turbulence properties from model
const phaseCompressibleTurbulenceModel& turbModel =
db().lookupObject<phaseCompressibleTurbulenceModel>
(
IOobject::groupName(turbulenceModel::propertiesName, phase.name())
);
const scalar Cmu25 = pow025(Cmu_);
const scalarField& y = turbModel.y()[patchi];
const tmp<scalarField> tmuw = turbModel.mu(patchi);
const scalarField& muw = tmuw();
const tmp<scalarField> talphaw = phase.thermo().alpha(patchi);
const scalarField& alphaw = talphaw();
const tmp<volScalarField> tk = turbModel.k();
const volScalarField& k = tk();
const fvPatchScalarField& kw = k.boundaryField()[patchi];
const fvPatchVectorField& Uw = turbModel.U().boundaryField()[patchi];
const scalarField magUp(mag(Uw.patchInternalField() - Uw));
const scalarField magGradUw(mag(Uw.snGrad()));
const fvPatchScalarField& rhow = turbModel.rho().boundaryField()[patchi];
const fvPatchScalarField& hew =
phase.thermo().he().boundaryField()[patchi];
const fvPatchScalarField& Tw =
phase.thermo().T().boundaryField()[patchi];
scalarField Tp(Tw.patchInternalField());
// Heat flux [W/m2] - lagging alphatw
const scalarField qDot
(
(prevAlphat + alphaw)*hew.snGrad()
);
scalarField uTau(Cmu25*sqrt(kw));
scalarField yPlus(uTau*y/(muw/rhow));
scalarField Pr(muw/alphaw);
// Molecular-to-turbulent Prandtl number ratio
scalarField Prat(Pr/Prt_);
// Thermal sublayer thickness
scalarField P(this->Psmooth(Prat));
scalarField yPlusTherm(this->yPlusTherm(P, Prat));
tmp<scalarField> talphatConv(new scalarField(this->size()));
scalarField& alphatConv = talphatConv.ref();
// Populate boundary values
forAll(alphatConv, facei)
{
// Evaluate new effective thermal diffusivity
scalar alphaEff = 0.0;
if (yPlus[facei] < yPlusTherm[facei])
{
scalar A = qDot[facei]*rhow[facei]*uTau[facei]*y[facei];
scalar B = qDot[facei]*Pr[facei]*yPlus[facei];
scalar C = Pr[facei]*0.5*rhow[facei]*uTau[facei]*sqr(magUp[facei]);
alphaEff = A/(B + C + vSmall);
}
else
{
scalar A = qDot[facei]*rhow[facei]*uTau[facei]*y[facei];
scalar B =
qDot[facei]*Prt_*(1.0/kappa_*log(E_*yPlus[facei]) + P[facei]);
scalar magUc =
uTau[facei]/kappa_*log(E_*yPlusTherm[facei]) - mag(Uw[facei]);
scalar C =
0.5*rhow[facei]*uTau[facei]
*(Prt_*sqr(magUp[facei]) + (Pr[facei] - Prt_)*sqr(magUc));
alphaEff = A/(B + C + vSmall);
}
// Update convective heat transfer turbulent thermal diffusivity
alphatConv[facei] = max(0.0, alphaEff - alphaw[facei]);
}
tmp<volScalarField> v2f<BasicTurbulenceModel>::Ls() const
{
return
CL_*max(pow(k_, 1.5)
/epsilon_, Ceta_*pow025(pow3(this->nu())/epsilon_));
}
tmp<scalargpuField> nutkAtmRoughWallFunctionFvPatchScalarField::calcNut() const
{
const label patchi = patch().index();
const turbulenceModel& turbulence = db().lookupObject<turbulenceModel>
(
IOobject::groupName
(
turbulenceModel::propertiesName,
dimensionedInternalField().group()
)
);
const scalargpuField& y = turbulence.y()[patchi];
const tmp<volScalarField> tk = turbulence.k();
const volScalarField& k = tk();
const tmp<scalargpuField> tnuw = turbulence.nu(patchi);
const scalargpuField& nuw = tnuw();
const scalar Cmu25 = pow025(Cmu_);
tmp<scalargpuField> tnutw(new scalargpuField(*this));
scalargpuField& nutw = tnutw();
thrust::transform
(
y.begin(),
y.end(),
thrust::make_zip_iterator(thrust::make_tuple
(
thrust::make_permutation_iterator
(
k.getField().begin(),
patch().faceCells().begin()
),
nuw.begin(),
z0_.begin()
)),
nutw.begin(),
nutkAtmRoughWallFunctionCalcNutFunctor(Cmu25,kappa_)
);
/*
forAll(nutw, faceI)
{
label faceCellI = patch().faceCells()[faceI];
scalar uStar = Cmu25*sqrt(k[faceCellI]);
scalar yPlus = uStar*y[faceI]/nuw[faceI];
scalar Edash = (y[faceI] + z0_[faceI])/z0_[faceI];
nutw[faceI] =
nuw[faceI]*(yPlus*kappa_/log(max(Edash, 1+1e-4)) - 1);
if (debug)
{
Info<< "yPlus = " << yPlus
<< ", Edash = " << Edash
<< ", nutw = " << nutw[faceI]
<< endl;
}
}
*/
return tnutw;
}
void alphatFixedDmdtWallBoilingWallFunctionFvPatchScalarField::updateCoeffs()
{
if (updated())
{
return;
}
// Lookup the fluid model
const ThermalPhaseChangePhaseSystem
<
MomentumTransferPhaseSystem<twoPhaseSystem>
>& fluid =
refCast
<
const ThermalPhaseChangePhaseSystem
<
MomentumTransferPhaseSystem<twoPhaseSystem>
>
>
(
db().lookupObject<phaseSystem>("phaseProperties")
);
const phaseModel& liquid
(
fluid.phase1().name() == dimensionedInternalField().group()
? fluid.phase1()
: fluid.phase2()
);
const label patchi = patch().index();
// Retrieve turbulence properties from model
const compressibleTurbulenceModel& turbModel =
db().lookupObject<compressibleTurbulenceModel>
(
IOobject::groupName
(
compressibleTurbulenceModel::propertiesName,
dimensionedInternalField().group()
)
);
const scalar Cmu25 = pow025(Cmu_);
const scalarField& y = turbModel.y()[patchi];
const tmp<scalarField> tmuw = turbModel.mu(patchi);
const scalarField& muw = tmuw();
const tmp<scalarField> talphaw = liquid.thermo().alpha(patchi);
const scalarField& alphaw = talphaw();
scalarField& alphatw = *this;
const tmp<volScalarField> tk = turbModel.k();
const volScalarField& k = tk();
const fvPatchScalarField& kw = k.boundaryField()[patchi];
const fvPatchVectorField& Uw = turbModel.U().boundaryField()[patchi];
const scalarField magUp(mag(Uw.patchInternalField() - Uw));
const scalarField magGradUw(mag(Uw.snGrad()));
const fvPatchScalarField& rhow = turbModel.rho().boundaryField()[patchi];
const fvPatchScalarField& hew =
liquid.thermo().he().boundaryField()[patchi];
const fvPatchScalarField& Tw =
liquid.thermo().T().boundaryField()[patchi];
scalarField Tp(Tw.patchInternalField());
// Heat flux [W/m2] - lagging alphatw
const scalarField qDot
(
(alphatw + alphaw)*hew.snGrad()
);
scalarField uTau(Cmu25*sqrt(kw));
scalarField yPlus(uTau*y/(muw/rhow));
scalarField Pr(muw/alphaw);
// Molecular-to-turbulent Prandtl number ratio
scalarField Prat(Pr/Prt_);
// Thermal sublayer thickness
scalarField P(this->Psmooth(Prat));
scalarField yPlusTherm(this->yPlusTherm(P, Prat));
scalarField alphatConv(this->size(), 0.0);
// Populate boundary values
forAll(alphatw, faceI)
{
// Evaluate new effective thermal diffusivity
scalar alphaEff = 0.0;
if (yPlus[faceI] < yPlusTherm[faceI])
{
scalar A = qDot[faceI]*rhow[faceI]*uTau[faceI]*y[faceI];
scalar B = qDot[faceI]*Pr[faceI]*yPlus[faceI];
scalar C = Pr[faceI]*0.5*rhow[faceI]*uTau[faceI]*sqr(magUp[faceI]);
alphaEff = A/(B + C + VSMALL);
}
else
{
scalar A = qDot[faceI]*rhow[faceI]*uTau[faceI]*y[faceI];
scalar B =
qDot[faceI]*Prt_*(1.0/kappa_*log(E_*yPlus[faceI]) + P[faceI]);
scalar magUc =
uTau[faceI]/kappa_*log(E_*yPlusTherm[faceI]) - mag(Uw[faceI]);
scalar C =
0.5*rhow[faceI]*uTau[faceI]
*(Prt_*sqr(magUp[faceI]) + (Pr[faceI] - Prt_)*sqr(magUc));
alphaEff = A/(B + C + VSMALL);
}
// Update convective heat transfer turbulent thermal diffusivity
alphatConv[faceI] = max(0.0, alphaEff - alphaw[faceI]);
}
void Foam::PairSpringSliderDashpot<CloudType>::evaluatePair
(
typename CloudType::parcelType& pA,
typename CloudType::parcelType& pB
) const
{
vector r_AB = (pA.position() - pB.position());
scalar dAEff = pA.d();
if (useEquivalentSize_)
{
dAEff *= cbrt(pA.nParticle()*volumeFactor_);
}
scalar dBEff = pB.d();
if (useEquivalentSize_)
{
dBEff *= cbrt(pB.nParticle()*volumeFactor_);
}
scalar r_AB_mag = mag(r_AB);
scalar normalOverlapMag = 0.5*(dAEff + dBEff) - r_AB_mag;
if (normalOverlapMag > 0)
{
//Particles in collision
vector rHat_AB = r_AB/(r_AB_mag + VSMALL);
vector U_AB = pA.U() - pB.U();
// Effective radius
scalar R = 0.5*dAEff*dBEff/(dAEff + dBEff);
// Effective mass
scalar M = pA.mass()*pB.mass()/(pA.mass() + pB.mass());
scalar kN = (4.0/3.0)*sqrt(R)*Estar_;
scalar etaN = alpha_*sqrt(M*kN)*pow025(normalOverlapMag);
// Normal force
vector fN_AB =
rHat_AB
*(kN*pow(normalOverlapMag, b_) - etaN*(U_AB & rHat_AB));
// Cohesion force
if (cohesion_)
{
fN_AB +=
-cohesionEnergyDensity_
*overlapArea(dAEff/2.0, dBEff/2.0, r_AB_mag)
*rHat_AB;
}
pA.f() += fN_AB;
pB.f() += -fN_AB;
vector USlip_AB =
U_AB - (U_AB & rHat_AB)*rHat_AB
+ (pA.omega() ^ (dAEff/2*-rHat_AB))
- (pB.omega() ^ (dBEff/2*rHat_AB));
scalar deltaT = this->owner().mesh().time().deltaTValue();
vector& tangentialOverlap_AB =
pA.collisionRecords().matchPairRecord
(
pB.origProc(),
pB.origId()
).collisionData();
vector& tangentialOverlap_BA =
pB.collisionRecords().matchPairRecord
(
pA.origProc(),
pA.origId()
).collisionData();
vector deltaTangentialOverlap_AB = USlip_AB*deltaT;
tangentialOverlap_AB += deltaTangentialOverlap_AB;
tangentialOverlap_BA += -deltaTangentialOverlap_AB;
scalar tangentialOverlapMag = mag(tangentialOverlap_AB);
if (tangentialOverlapMag > VSMALL)
{
scalar kT = 8.0*sqrt(R*normalOverlapMag)*Gstar_;
scalar etaT = etaN;
// Tangential force
vector fT_AB;
if (kT*tangentialOverlapMag > mu_*mag(fN_AB))
{
// Tangential force greater than sliding friction,
// particle slips
fT_AB = -mu_*mag(fN_AB)*USlip_AB/mag(USlip_AB);
tangentialOverlap_AB = vector::zero;
tangentialOverlap_BA = vector::zero;
}
else
{
fT_AB =
-kT*tangentialOverlapMag
*tangentialOverlap_AB/tangentialOverlapMag
- etaT*USlip_AB;
}
pA.f() += fT_AB;
pB.f() += -fT_AB;
pA.torque() += (dAEff/2*-rHat_AB) ^ fT_AB;
pB.torque() += (dBEff/2*rHat_AB) ^ -fT_AB;
}
}
}
void Foam::epsilonLowReWallFunctionFvPatchScalarField::calculate
(
const turbulenceModel& turbModel,
const List<scalar>& cornerWeights,
const fvPatch& patch,
scalarField& G0,
scalarField& epsilon0
)
{
const label patchi = patch.index();
const scalarField& y = turbModel.y()[patchi];
const scalar Cmu25 = pow025(Cmu_);
const scalar Cmu75 = pow(Cmu_, 0.75);
const tmp<volScalarField> tk = turbModel.k();
const volScalarField& k = tk();
const tmp<scalarField> tnuw = turbModel.nu(patchi);
const scalarField& nuw = tnuw();
const tmp<scalarField> tnutw = turbModel.nut(patchi);
const scalarField& nutw = tnutw();
const fvPatchVectorField& Uw = turbModel.U().boundaryField()[patchi];
const scalarField magGradUw(mag(Uw.snGrad()));
const DimensionedField<scalar, volMesh>& G =
db().lookupObject<DimensionedField<scalar, volMesh> >
(
turbModel.GName()
);
// Set epsilon and G
forAll(nutw, facei)
{
label celli = patch.faceCells()[facei];
scalar yPlus = Cmu25*sqrt(k[celli])*y[facei]/nuw[facei];
scalar w = cornerWeights[facei];
if (yPlus > yPlusLam_)
{
epsilon0[celli] += w*Cmu75*pow(k[celli], 1.5)/(kappa_*y[facei]);
G0[celli] +=
w
*(nutw[facei] + nuw[facei])
*magGradUw[facei]
*Cmu25*sqrt(k[celli])
/(kappa_*y[facei]);
}
else
{
epsilon0[celli] += w*2.0*k[celli]*nuw[facei]/sqr(y[facei]);
G0[celli] += G[celli];
}
}
tmp<scalargpuField> nutkRoughWallFunctionFvPatchScalarField::calcNut() const
{
const label patchi = patch().index();
const turbulenceModel& turbModel = db().lookupObject<turbulenceModel>
(
IOobject::groupName
(
turbulenceModel::propertiesName,
dimensionedInternalField().group()
)
);
const scalargpuField& y = turbModel.y()[patchi];
const tmp<volScalarField> tk = turbModel.k();
const volScalarField& k = tk();
const tmp<scalargpuField> tnuw = turbModel.nu(patchi);
const scalargpuField& nuw = tnuw();
const scalar Cmu25 = pow025(Cmu_);
tmp<scalargpuField> tnutw(new scalargpuField(*this));
scalargpuField& nutw = tnutw();
thrust::transform
(
y.begin(),
y.end(),
thrust::make_zip_iterator(thrust::make_tuple
(
thrust::make_permutation_iterator
(
k.getField().begin(),
patch().faceCells().begin()
),
nuw.begin(),
nutw.begin(),
Ks_.begin(),
Cs_.begin()
)),
nutw.begin(),
calcNutFunctor(Cmu25,kappa_,E_)
);
/*
forAll(nutw, faceI)
{
label faceCellI = patch().faceCells()[faceI];
scalar uStar = Cmu25*sqrt(k[faceCellI]);
scalar yPlus = uStar*y[faceI]/nuw[faceI];
scalar KsPlus = uStar*Ks_[faceI]/nuw[faceI];
scalar Edash = E_;
if (KsPlus > 2.25)
{
Edash /= fnRough(KsPlus, Cs_[faceI]);
}
scalar limitingNutw = max(nutw[faceI], nuw[faceI]);
// To avoid oscillations limit the change in the wall viscosity
// which is particularly important if it temporarily becomes zero
nutw[faceI] =
max
(
min
(
nuw[faceI]
*(yPlus*kappa_/log(max(Edash*yPlus, 1+1e-4)) - 1),
2*limitingNutw
), 0.5*limitingNutw
);
if (debug)
{
Info<< "yPlus = " << yPlus
<< ", KsPlus = " << KsPlus
<< ", Edash = " << Edash
<< ", nutw = " << nutw[faceI]
<< endl;
}
}
*/
return tnutw;
}
