Foam::forceSuSp Foam::DPMDragModels::ErgunWenYu<CloudType>::calcCoupled
(
const typename CloudType::parcelType& p,
const scalar dt,
const scalar mass,
const scalar Re,
const scalar muc
) const
{
scalar alphac(alphac_[p.cell()]);
if (alphac < 0.8)
{
return forceSuSp
(
vector::zero,
(mass/p.rho())
*((150.0*(1.0 - alphac) + 1.75*Re)*muc/(alphac*sqr(p.d())))
);
}
else
{
return forceSuSp
(
vector::zero,
(mass/p.rho())
*0.75*CdRe(alphac*Re)*muc*pow(alphac, -2.65)/sqr(p.d())
);
}
}
Foam::scalar Foam::LambertWall<CloudType>::pREff
(
const typename CloudType::parcelType& p
) const
{
if (useEquivalentSize_)
{
return p.d()/2*cbrt(p.nParticle()*volumeFactor_);
}
else
{
return p.d()/2;
}
}
Foam::scalar Foam::WallLocalSpringSliderDashpot<CloudType>::pREff
(
const typename CloudType::parcelType& p
) const
{
if (useEquivalentSize_)
{
return p.d()/2*cbrt(p.nParticle()*volumeFactor_);
}
else
{
return p.d()/2;
}
}
Foam::scalar Foam::NoPendularWall<CloudType>::pREff
(
const typename CloudType::parcelType& p
) const
{
return p.d()/2;
}
Foam::forceSuSp Foam::PlessisMasliyahDragForce<CloudType>::calcCoupled
(
const typename CloudType::parcelType& p,
const scalar dt,
const scalar mass,
const scalar Re,
const scalar muc
) const
{
scalar alphac(alphac_[p.cell()]);
scalar cbrtAlphap(pow(1.0 - alphac, 1.0/3.0));
scalar A =
26.8*pow3(alphac)
/(
sqr(cbrtAlphap)
*(1.0 - cbrtAlphap)
*sqr(1.0 - sqr(cbrtAlphap))
+ SMALL
);
scalar B =
sqr(alphac)
/sqr(1.0 - sqr(cbrtAlphap));
return forceSuSp
(
vector::zero,
(mass/p.rho())
*(A*(1.0 - alphac) + B*Re)*muc/(alphac*sqr(p.d()))
);
}
void Foam::ConeInjection<CloudType>::setProperties
(
const label parcelI,
const label,
const scalar time,
typename CloudType::parcelType& parcel
)
{
// set particle velocity
const scalar deg2Rad = mathematicalConstant::pi/180.0;
scalar t = time - this->SOI_;
scalar ti = thetaInner_().value(t);
scalar to = thetaOuter_().value(t);
scalar coneAngle = this->owner().rndGen().scalar01()*(to - ti) + ti;
coneAngle *= deg2Rad;
scalar alpha = sin(coneAngle);
scalar dcorr = cos(coneAngle);
scalar beta = mathematicalConstant::twoPi*this->owner().rndGen().scalar01();
vector normal = alpha*(tanVec1_*cos(beta) + tanVec2_*sin(beta));
vector dirVec = dcorr*direction_;
dirVec += normal;
dirVec /= mag(dirVec);
parcel.U() = Umag_().value(t)*dirVec;
// set particle diameter
parcel.d() = parcelPDF_().sample();
}
void Foam::PatchInjection<CloudType>::setProperties
(
const label,
const label,
const scalar,
typename CloudType::parcelType& parcel
)
{
// set particle velocity
parcel.U() = U0_;
// set particle diameter
parcel.d() = parcelPDF_->sample();
}
void Foam::NoInjection<CloudType>::setProperties
(
const label,
const label,
const scalar,
typename CloudType::parcelType& parcel
)
{
// set particle velocity
parcel.U() = vector::zero;
// set particle diameter
parcel.d() = 0.0;
}
void Foam::ManualInjection<CloudType>::setProperties
(
const label parcelI,
const label,
const scalar,
typename CloudType::parcelType& parcel
)
{
// set particle velocity
parcel.U() = U0_;
// set particle diameter
parcel.d() = diameters_[parcelI];
}
Foam::forceSuSp Foam::SphereDragForce<CloudType>::calcCoupled
(
const typename CloudType::parcelType& p,
const scalar dt,
const scalar mass,
const scalar Re,
const scalar muc
) const
{
forceSuSp value(vector::zero, 0.0);
value.Sp() = mass*0.75*muc*CdRe(Re)/(p.rho()*sqr(p.d()));
return value;
}
Foam::forceSuSp Foam::BrownianMotionForce<CloudType>::calcCoupled
(
const typename CloudType::parcelType& p,
const scalar dt,
const scalar mass,
const scalar Re,
const scalar muc
) const
{
forceSuSp value(vector::zero, 0.0);
const scalar dp = p.d();
const scalar Tc = p.Tc();
const scalar eta = rndGen_.sample01<scalar>();
const scalar alpha = 2.0*lambda_/dp;
const scalar cc = 1.0 + alpha*(1.257 + 0.4*exp(-1.1/alpha));
const scalar sigma = physicoChemical::sigma.value();
scalar f = 0.0;
if (turbulence_)
{
const label cellI = p.cell();
const volScalarField& k = *kPtr_;
const scalar kc = k[cellI];
const scalar Dp = sigma*Tc*cc/(3*mathematical::pi*muc*dp);
f = eta/mass*sqrt(2.0*sqr(kc)*sqr(Tc)/(Dp*dt));
}
else
{
const scalar rhoRatio = p.rho()/p.rhoc();
const scalar s0 =
216*muc*sigma*Tc/(sqr(mathematical::pi)*pow5(dp)*(rhoRatio)*cc);
f = eta*sqrt(mathematical::pi*s0/dt);
}
const scalar sqrt2 = sqrt(2.0);
for (label i = 0; i < 3; i++)
{
const scalar x = rndGen_.sample01<scalar>();
const scalar eta = sqrt2*erfInv(2*x - 1.0);
value.Su()[i] = mass*f*eta;
}
return value;
}
void Foam::ManualInjectionWet<CloudType>::setProperties
(
const label parcelI,
const label,
const scalar,
typename CloudType::parcelType& parcel
)
{
// set particle velocity
parcel.U() = U0_;
// set particle diameter
parcel.d() = diameters_[parcelI];
// set initial liquid volume
parcel.Vliq() = iniVliq_;
}
Foam::forceSuSp Foam::WenYuDragForce<CloudType>::calcCoupled
(
const typename CloudType::parcelType& p,
const scalar dt,
const scalar mass,
const scalar Re,
const scalar muc
) const
{
scalar alphac(alphac_[p.cell()]);
return forceSuSp
(
vector::zero,
(mass/p.rho())
*0.75*CdRe(alphac*Re)*muc*pow(alphac, -2.65)/(alphac*sqr(p.d()))
);
}
Foam::forceSuSp Foam::LiftForce<CloudType>::calcCoupled
(
const typename CloudType::parcelType& p,
const scalar dt,
const scalar mass,
const scalar Re,
const scalar muc
) const
{
forceSuSp value(vector::zero, 0.0);
vector curlUc =
curlUcInterp().interpolate(p.position(), p.currentTetIndices());
scalar Cl = this->Cl(p, curlUc, Re, muc);
value.Su() = mass/p.rho()*p.d()/2.0*p.rhoc()*Cl*((p.Uc() - p.U())^curlUc);
return value;
}
void Foam::SwakScriptableInjection<CloudType>::setProperties
(
const label parcelI,
const label,
const scalar,
typename CloudType::parcelType& parcel
)
{
// set particle velocity
scalarField U0Vals(particleData_["U0"]);
if(U0Vals.size()<3) {
FatalErrorIn("void Foam::SwakScriptableInjection<CloudType>::setPositionAndCell")
<< "Expected a list with at least 3 values. Got " << U0Vals
<< endl
<< exit(FatalError);
}
parcel.U() = vector(U0Vals[0],U0Vals[1],U0Vals[2]);
// set particle diameter
parcel.d() = readScalar(particleData_["diameter"]);
// Info << parcel << endl;
}
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;
}
}
}
Foam::forceSuSp Foam::BrownianMotionForce<CloudType>::calcCoupled
(
const typename CloudType::parcelType& p,
const typename CloudType::parcelType::trackingData& td,
const scalar dt,
const scalar mass,
const scalar Re,
const scalar muc
) const
{
forceSuSp value(Zero, 0.0);
const scalar dp = p.d();
const scalar Tc = td.Tc();
const scalar alpha = 2.0*lambda_/dp;
const scalar cc = 1.0 + alpha*(1.257 + 0.4*exp(-1.1/alpha));
// Boltzmann constant
const scalar kb = physicoChemical::k.value();
scalar f = 0;
if (turbulence_)
{
const label celli = p.cell();
const volScalarField& k = *kPtr_;
const scalar kc = k[celli];
const scalar Dp = kb*Tc*cc/(3*mathematical::pi*muc*dp);
f = sqrt(2.0*sqr(kc)*sqr(Tc)/(Dp*dt));
}
else
{
const scalar s0 =
216*muc*kb*Tc/(sqr(mathematical::pi)*pow5(dp)*sqr(p.rho())*cc);
f = mass*sqrt(mathematical::pi*s0/dt);
}
// To generate a cubic distribution (3 independent directions) :
// const scalar sqrt2 = sqrt(2.0);
// for (direction dir = 0; dir < vector::nComponents; dir++)
// {
// const scalar x = rndGen_.sample01<scalar>();
// const scalar eta = sqrt2*erfInv(2*x - 1.0);
// value.Su()[dir] = f*eta;
// }
// To generate a spherical distribution:
Random& rnd = this->owner().rndGen();
const scalar theta = rnd.scalar01()*twoPi;
const scalar u = 2*rnd.scalar01() - 1;
const scalar a = sqrt(1 - sqr(u));
const vector dir(a*cos(theta), a*sin(theta), u);
value.Su() = f*mag(rnd.scalarNormal())*dir;
return value;
}