ENH: ParticleFunctionObjects: Added PatchCollisionDensity object

This function object will write a paraview-viewable field showing the
area-density of parcel collisions on every patch face. It also outputs
the rate of collisions hitting each patch face, calculated over an
interval equal to the time elapsed since the last output. It has an
optional entry to specify a minimum incident speed below which a
collision is not counted.

It can be enabled in the cloud properties file as follows:

    cloudFunctions
    {
        patchCollisionDensity1
        {
            type        patchCollisionDensity;
            minSpeed    1e-3; // (optional)
        }
    }

This work was supported by Anton Kidess, at Hilti

src/lagrangian/intermediate/parcels/include/makeParcelCloudFunctionObjects.H

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011-2016 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2018 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -34,6 +34,7 @@ License
 #include "ParticleErosion.H"
 #include "ParticleTracks.H"
 #include "ParticleTrap.H"
+#include "PatchCollisionDensity.H"
 #include "PatchPostProcessing.H"
 #include "VoidFraction.H"
 
@@ -48,6 +49,7 @@ License
     makeCloudFunctionObjectType(ParticleErosion, CloudType);                   \
     makeCloudFunctionObjectType(ParticleTracks, CloudType);                    \
     makeCloudFunctionObjectType(ParticleTrap, CloudType);                      \
+    makeCloudFunctionObjectType(PatchCollisionDensity, CloudType);             \
     makeCloudFunctionObjectType(PatchPostProcessing, CloudType);               \
     makeCloudFunctionObjectType(VoidFraction, CloudType);
 

src/lagrangian/intermediate/submodels/CloudFunctionObjects/PatchCollisionDensity/PatchCollisionDensity.C

@@ -0,0 +1,168 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2018 OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "PatchCollisionDensity.H"
+#include "Pstream.H"
+#include "stringListOps.H"
+#include "ListOps.H"
+#include "ListListOps.H"
+
+// * * * * * * * * * * * * * Protected Member Functions  * * * * * * * * * * //
+
+template<class CloudType>
+void Foam::PatchCollisionDensity<CloudType>::write()
+{
+    const scalarField z(this->owner().mesh().nCells(), 0);
+
+    volScalarField
+    (
+        IOobject
+        (
+            this->owner().name() + ":collisionDensity",
+            this->owner().mesh().time().timeName(),
+            this->owner().mesh()
+        ),
+        this->owner().mesh(),
+        dimless/dimArea,
+        z,
+        collisionDensity_
+    )
+   .write();
+
+    volScalarField
+    (
+        IOobject
+        (
+            this->owner().name() + ":collisionDensityRate",
+            this->owner().mesh().time().timeName(),
+            this->owner().mesh()
+        ),
+        this->owner().mesh(),
+        dimless/dimArea/dimTime,
+        z,
+        (collisionDensity_ - collisionDensity0_)
+       /(this->owner().mesh().time().value() - time0_)
+    )
+   .write();
+
+    collisionDensity0_ == collisionDensity_;
+    time0_ = this->owner().mesh().time().value();
+}
+
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+template<class CloudType>
+Foam::PatchCollisionDensity<CloudType>::PatchCollisionDensity
+(
+    const dictionary& dict,
+    CloudType& owner,
+    const word& modelName
+)
+:
+    CloudFunctionObject<CloudType>(dict, owner, modelName, typeName),
+    minSpeed_(dict.lookupOrDefault<scalar>("minSpeed", -1)),
+    collisionDensity_
+    (
+        this->owner().mesh().boundary(),
+        volScalarField::Internal::null(),
+        calculatedFvPatchField<scalar>::typeName
+    ),
+    collisionDensity0_
+    (
+        this->owner().mesh().boundary(),
+        volScalarField::Internal::null(),
+        calculatedFvPatchField<scalar>::typeName
+    ),
+    time0_(this->owner().mesh().time().value())
+{
+    collisionDensity_ == 0;
+    collisionDensity0_ == 0;
+
+    IOobject io
+    (
+        this->owner().name() + ":collisionDensity",
+        this->owner().mesh().time().timeName(),
+        this->owner().mesh(),
+        IOobject::MUST_READ,
+        IOobject::NO_WRITE
+    );
+
+    if (io.typeHeaderOk<volScalarField>())
+    {
+        const volScalarField collisionDensity(io, this->owner().mesh());
+        collisionDensity_ == collisionDensity.boundaryField();
+        collisionDensity0_ == collisionDensity.boundaryField();
+    }
+}
+
+
+template<class CloudType>
+Foam::PatchCollisionDensity<CloudType>::PatchCollisionDensity
+(
+    const PatchCollisionDensity<CloudType>& ppm
+)
+:
+    CloudFunctionObject<CloudType>(ppm),
+    minSpeed_(ppm.minSpeed_),
+    collisionDensity_(ppm.collisionDensity_),
+    collisionDensity0_(ppm.collisionDensity0_),
+    time0_(ppm.time0_)
+{}
+
+
+// * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
+
+template<class CloudType>
+Foam::PatchCollisionDensity<CloudType>::~PatchCollisionDensity()
+{}
+
+
+// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
+
+template<class CloudType>
+void Foam::PatchCollisionDensity<CloudType>::postPatch
+(
+    const parcelType& p,
+    const polyPatch& pp,
+    bool&
+)
+{
+    const label patchi = pp.index();
+    const label patchFacei = p.face() - pp.start();
+
+    vector nw, Up;
+    this->owner().patchData(p, pp, nw, Up);
+
+    const scalar speed = (p.U() - Up) & nw;
+    if (speed > minSpeed_)
+    {
+        collisionDensity_[patchi][patchFacei] +=
+            1/this->owner().mesh().magSf().boundaryField()[patchi][patchFacei];
+    }
+}
+
+
+// ************************************************************************* //

src/lagrangian/intermediate/submodels/CloudFunctionObjects/PatchCollisionDensity/PatchCollisionDensity.H

@@ -0,0 +1,152 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2018 OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+Class
+    Foam::PatchCollisionDensity
+
+Description
+    Function object which generates fields of the number and rate of collisions
+    per unit area on all patches. Can optionally take a minimum speed below
+    which a collision is not counted.
+
+    Example usage:
+    \verbatim
+    patchCollisionDensity1
+    {
+        type        patchCollisionDensity;
+        minSpeed    1e-3;
+    }
+    \endverbatim
+
+SourceFiles
+    PatchCollisionDensity.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef PatchCollisionDensity_H
+#define PatchCollisionDensity_H
+
+#include "CloudFunctionObject.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+/*---------------------------------------------------------------------------*\
+                    Class PatchCollisionDensity Declaration
+\*---------------------------------------------------------------------------*/
+
+template<class CloudType>
+class PatchCollisionDensity
+:
+    public CloudFunctionObject<CloudType>
+{
+    // Private data
+
+        typedef typename CloudType::particleType parcelType;
+
+        //- The threshold for a collision
+        const scalar minSpeed_;
+
+        //- The field of the number of collisions per unit area
+        volScalarField::Boundary collisionDensity_;
+
+        //- The field of the number of collisions per unit area at the last
+        //  output
+        volScalarField::Boundary collisionDensity0_;
+
+        //- The time at the last output
+        scalar time0_;
+
+
+protected:
+
+    // Protected Member Functions
+
+        //- Write post-processing info
+        void write();
+
+
+public:
+
+    //- Runtime type information
+    TypeName("patchCollisionDensity");
+
+
+    // Constructors
+
+        //- Construct from dictionary
+        PatchCollisionDensity
+        (
+            const dictionary& dict,
+            CloudType& owner,
+            const word& modelName
+        );
+
+        //- Construct copy
+        PatchCollisionDensity(const PatchCollisionDensity<CloudType>& ppm);
+
+        //- Construct and return a clone
+        virtual autoPtr<CloudFunctionObject<CloudType>> clone() const
+        {
+            return autoPtr<CloudFunctionObject<CloudType>>
+            (
+                new PatchCollisionDensity<CloudType>(*this)
+            );
+        }
+
+
+    //- Destructor
+    virtual ~PatchCollisionDensity();
+
+
+    // Member Functions
+
+        // Evaluation
+
+            //- Post-patch hook
+            virtual void postPatch
+            (
+                const parcelType& p,
+                const polyPatch& pp,
+                bool& keepParticle
+            );
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#ifdef NoRepository
+    #include "PatchCollisionDensity.C"
+#endif
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //