[Luke99]

So i've been looking into Lagrangian particles and clouds in OpenFOAM. From what I gathered, they don't store their individual velocities but rely on the underlying velocity field to move them.

If this is not the case which code should i look into to see where and how the particles individual velocity is stored

[GerhardHolzinger]

What makes you think, that the particles do not store their velocity?


If a particle wants to compute the drag it expierences, the difference between its and the surrounding fluid's velocity is the relevant input. Hence, the particle has indeed the need to remember/store its velocity.
Otherwise, you would not be able to have anything other than fine dust that ideally follows the surrounding fluid. If you spray drops into stagnant air, the drops have a velocity that is independent of the fluid velocity. There's coupling via drag and other interaction forces, however, particle velocity is part of a particle's state, and therefore needs to be stored.



I did a deep dive into the Lagrangian classes a couple of years ago, you can find my findings in Section "The Lagrangian world" in https://github.com/ParticulateFlow/OSCCAR-doc


Note, that this are the musings of an experienced layperson and not official OpenFOAM documentation. Hence, it may very well be flawed, incomplete, outdated and suffer from many other problems.
However, it might help you get an overview of how things are organised, and where you might find things.

[Luke99]

I looked into the code or at least I tried to and couldn't find any reference to particle velocities.
But thank you for clarifying and your PDF is good start for understanding. Thanks for that.

[GerhardHolzinger]

... well, due to OpenFOAM's clever use of abstraction, some things aren't as obvious as one would expect.


However, I've found something ...
First, I looked at the drag models, since I used drag as an example in my earlier explanation. However, all drag models I looked at are formulated in terms of particle Reynolds number. While this is indirect proof of a particle velocity, I wanted something that uses the particle's velocity explicitely.


Below, you see some code of the particleErosion sub-model. The damage a particle causes when it crashes into a wall depends on its velocity, and voila, there's use of the particle's velocity.

template<class CloudType>
void Foam::ParticleErosion<CloudType>::postPatch
(
    const parcelType& p,
    const polyPatch& pp
)
{
    const label patchi = pp.index();
    const label localPatchi = applyToPatch(patchi);

    if (localPatchi != -1)
    {
        // Get patch data
        vector nw, Up;
        this->owner().patchData(p, pp, nw, Up);

        // Particle velocity relative to patch
        const vector& U = p.U() - Up;

        // Quick rejection if the particle is travelling away from the patch
        if ((nw & U) < 0)
        {
            return;
        }

        const scalar magU = mag(U);
        const vector UHat = U/magU;

        // Impact angle
        const scalar alpha = mathematical::pi/2 - acos(nw & UHat);

        // Get the face value to accumulate into
        const label patchFacei = pp.whichFace(p.face());
        scalar& Q = QPtr_->boundaryFieldRef()[patchi][patchFacei];

        // Finnie's model
        const scalar coeff = p.nParticle()*p.mass()*sqr(magU)/(p_*psi_*K_);
        if (tan(alpha) < K_/6)
        {
            Q += coeff*(sin(2*alpha) - 6/K_*sqr(sin(alpha)));
        }
        else
        {
            Q += coeff*(K_*sqr(cos(alpha))/6);
        }
    }
}