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; } }
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; } } }
bool Foam::StandardWallInteraction<CloudType>::correct ( typename CloudType::parcelType& p, const polyPatch& pp, bool& keepParticle, const scalar trackFraction, const tetIndices& tetIs ) { vector& U = p.U(); bool& active = p.active(); if (isA<wallPolyPatch>(pp)) { switch (interactionType_) { case PatchInteractionModel<CloudType>::itEscape: { scalar dm = p.mass()*p.nParticle(); keepParticle = false; active = false; U = vector::zero; nEscape_++; massEscape_ += dm; break; } case PatchInteractionModel<CloudType>::itStick: { keepParticle = true; active = false; U = vector::zero; nStick_++; break; } case PatchInteractionModel<CloudType>::itRebound: { keepParticle = true; active = true; vector nw; vector Up; this->owner().patchData(p, pp, trackFraction, tetIs, nw, Up); // Calculate motion relative to patch velocity U -= Up; scalar Un = U & nw; vector Ut = U - Un*nw; if (Un > 0) { U -= (1.0 + e_)*Un*nw; } U -= mu_*Ut; // Return velocity to global space U += Up; break; } default: { FatalErrorIn ( "bool StandardWallInteraction<CloudType>::correct" "(" "typename CloudType::parcelType&, " "const polyPatch&, " "bool& keepParticle, " "const scalar, " "const tetIndices&" ") const" ) << "Unknown interaction type " << this->interactionTypeToWord(interactionType_) << "(" << interactionType_ << ")" << endl << abort(FatalError); } } return true; } return false; }
bool Foam::LocalInteraction<CloudType>::correct ( typename CloudType::parcelType& p, const polyPatch& pp, bool& keepParticle, const scalar trackFraction, const tetIndices& tetIs ) { label patchI = patchData_.applyToPatch(pp.index()); if (patchI >= 0) { vector& U = p.U(); bool& active = p.active(); typename PatchInteractionModel<CloudType>::interactionType it = this->wordToInteractionType ( patchData_[patchI].interactionTypeName() ); switch (it) { case PatchInteractionModel<CloudType>::itEscape: { scalar dm = p.mass()*p.nParticle(); keepParticle = false; active = false; U = vector::zero; nEscape_[patchI]++; massEscape_[patchI] += dm; if (writeFields_) { label pI = pp.index(); label fI = pp.whichFace(p.face()); massEscape().boundaryField()[pI][fI] += dm; } break; } case PatchInteractionModel<CloudType>::itStick: { scalar dm = p.mass()*p.nParticle(); keepParticle = true; active = false; U = vector::zero; nStick_[patchI]++; massStick_[patchI] += dm; if (writeFields_) { label pI = pp.index(); label fI = pp.whichFace(p.face()); massStick().boundaryField()[pI][fI] += dm; } break; } case PatchInteractionModel<CloudType>::itRebound: { keepParticle = true; active = true; vector nw; vector Up; this->owner().patchData(p, pp, trackFraction, tetIs, nw, Up); // Calculate motion relative to patch velocity U -= Up; scalar Un = U & nw; vector Ut = U - Un*nw; if (Un > 0) { U -= (1.0 + patchData_[patchI].e())*Un*nw; } U -= patchData_[patchI].mu()*Ut; // Return velocity to global space U += Up; break; } default: { FatalErrorIn ( "bool LocalInteraction<CloudType>::correct" "(" "typename CloudType::parcelType&, " "const polyPatch&, " "bool&, " "const scalar, " "const tetIndices&" ") const" ) << "Unknown interaction type " << patchData_[patchI].interactionTypeName() << "(" << it << ") for patch " << patchData_[patchI].patchName() << ". Valid selections are:" << this->interactionTypeNames_ << endl << abort(FatalError); } } return true; } return false; }