[reverseila]

Dear all,

In the particleTrackProperties there is one entry that I don't know what it is and/or what does it mean:

• sampleFrequency 1;

There's no explanation in the documentations of OpenFOAM website, and in comments of the source code of particleTracks utility whatsoever. I guess this is one of those not so uncommon moments that one needs to RTFS! Read The Freaking Sourcecode. Now, the following is what I was able to find out about this entry so far:


According to the source code of the particleTracks utility, sampleFrequency must be a number greater than or equal to 1:

    sampleFrequency = max(1, sampleFrequency);  // sanity

and is used later on to set the sample rate for the track sampler (whatever it is):

    trackSampler.setSampleRate(sampleFrequency, maxPositions, maxTracks);

which it seems that it determines the number of tracks (nTracks_). This is, as its name suggests, the number of tracks. but what is a track anyway (I think I need to know a bit about the terminology OpenFOAM uses for lagrangian stuff).
Here's the source code for setSampleRate:

        //- Set the sampling stride, upper limits
        //  \return Number of tracks to generate
        label setSampleRate
        (
            const label sampleFreq, // sampleFrequency is passed as the argument to this parameter
            const label maxPositions,
            const label maxTracks = -1
        )
        {
             // numTracks = numParticles/stride

            // stride_: the sampling interval
            stride_ = max(1, sampleFreq);
            maxPositions_ = maxPositions;
            nTracks_ = (origParcelAddr_.totalSize()/stride_);

            if (maxTracks > 0)
            {
                nTracks_ = min(nTracks_, maxTracks);
            }

            return nTracks_;
        }

I'm not sure what the line in red means.


EDIT (ADDED)<<<
Note that the value of the sampleFrequency is ended up being stored in the stride_ if its greater than 1.

Further in the code there's this function that creates track fields:

template<class Type>
void Foam::particleTracksSampler::createTrackField
(
    const UList<Type>& values,
    List<DynamicList<Type>>& trackValues
) const
{
    List<Type> allValues(cloudGather_.gather(values));

    const label nTracks = trackValues.size();

    forAll(allValues, i)
    {
        const label globalId =
            origParcelAddr_.toGlobal(origProcIds_[i], origParcelIds_[i]);

        if (globalId % stride_ == 0)
        {
            const label trackId = globalId/stride_;

            if
            (
                trackId < nTracks
             && trackValues[trackId].size() < maxPositions_
            )
            {
                trackValues[trackId].append(allValues[i]);
            }
        }
    }
}

Although I don't understand what does the code in red do, I feel, sampleFrequency (or -stride as commandline argument to particleTracks) is used to calculate track data only for those time step labels that are divisible by sampleFrequency (the code in blue). Therefore, reducing some amount of computation by omitting some tracking data. That's my understanding thus far. Let me know if this is wrong or inaccurate.
>>>EDIT (ADDED) END.


There's also a maxPositions entry in the dictionary. According to the source code:

//- Upper limit for number of track positions

As I don't know what the term track means, I don't know what maxPositions mean.