ParticleZoneInfo.H

Go to the documentation of this file.

/*---------------------------------------------------------------------------*\
  =========                 |
  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
   \\    /   O peration     |
    \\  /    A nd           | www.openfoam.com
     \\/     M anipulation  |
-------------------------------------------------------------------------------
    Copyright (C) 2022 OpenCFD Ltd.
-------------------------------------------------------------------------------
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::ParticleZoneInfo
 
Group
    grpLagrangianIntermediateFunctionObjects
 
Description
    Reports cloud information for particles passing through a specified cell
    zone.
 
Usage
    Example usage:
    \verbatim
    cloudFunctions
    {
        particleZoneInfo1
        {
            // Mandatory entries
            type            particleZoneInfo;
            cellZone        leftFluid;
 
            // Optional entries
            writer          vtk;
        }
    }
    \endverbatim
 
    Results are written to file:
    - <case>/postProcessing/lagrangian/<cloudName>/<functionName>/<time>
 
    \verbatim
    # cellZone        : leftFluid
    # time            : 1.0000000000e+00
    #
    # origID    origProc    (x y z)    time0    age    d0    d    mass0    mass
    \endverbatim
 
    Where
    - origID : particle ID
    - origProc : processor ID
    - (x y z) : Cartesian co-ordinates
    - time0 : time particle enters the cellZone
    - age : time spent in the cellZone
    - d0 : diameter on entry to the cellZone
    - d : current diameter
    - mass0 : mass on entry to the cellZone
    - mass : current mass
 
    If the optional \c writer entry is supplied, cloud data is written in the
    specified format.
 
    During the run, output statistics are reported after the cloud solution,
    e.g.:
 
    \verbatim
    particleZoneInfo:
        Cell zone                       = leftFluid
        Contributions                   = 257
    \endverbatim
 
    Here, 'Contributions' refers to the number of incremental particle-move
    contributions recorded during this time step. At write times, the output
    is extended, e.g.:
 
    \verbatim
    particleZoneInfo:
        Cell zone                       = leftFluid
        Contributions                   = 822
        Number of particles             = 199
        Written data to "postProcessing/lagrangian/reactingCloud1/
    \endverbatim
 
SourceFiles
    ParticleZoneInfo.C
 
\*---------------------------------------------------------------------------*/
 
#ifndef ParticleZoneInfo_H
#define ParticleZoneInfo_H
 
#include "CloudFunctionObject.H"
#include "writeFile.H"
#include "coordSetWriter.H"
 
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
namespace Foam
{
 
/*---------------------------------------------------------------------------*\
                        struct particleInfo Declaration
\*---------------------------------------------------------------------------*/
 
struct particleInfo
{
    label origID = -1;
    label origProc = -1;
    vector position = Zero;
    scalar time0 = 0;
    scalar age = 0;
    scalar d0 = 0;
    scalar d = 0;
    scalar mass0 = 0;
    scalar mass = 0;
 
    void operator+=(const particleInfo& p)
    {
        // Increment age
        age += p.age;
 
        // Set current values
        position = p.position;
        d = p.d;
        mass = p.mass;
    }
 
    scalar isOlderThan(const particleInfo& p) const
    {
        // Cannot just use time0 - particle may leave/re-enter and
        // so age is decoupled
        return (p.time0 + p.age) < (time0 + age);
    }
 
    friend bool operator==(const particleInfo& a, const particleInfo& b)
    {
        return
            a.origID == b.origID
         && a.origProc == b.origProc
         && a.position == b.position
         && a.time0 == b.time0
         && a.age == b.age
         && a.d0 == b.d0
         && a.d == b.d
         && a.mass0 == b.mass0
         && a.mass == b.mass;
    }
 
    friend bool operator!=(const particleInfo& a, const particleInfo& b)
    {
        return !(a == b);
    }
 
 
// IOstream Operators
 
    friend Istream& operator>>(Istream& is, particleInfo& pi)
    {
        is  >> pi.origID
            >> pi.origProc
            >> pi.position
            >> pi.time0
            >> pi.age
            >> pi.d0
            >> pi.d
            >> pi.mass0
            >> pi.mass;
 
        return is;
    }
 
    friend Ostream& operator<<(Ostream& os, const particleInfo& pi)
    {
        os  << pi.origID
            << " " << pi.origProc
            << " " << pi.position
            << " " << pi.time0
            << " " << pi.age
            << " " << pi.d0
            << " " << pi.d
            << " " << pi.mass0
            << " " << pi.mass;
 
        return os;
    }
};
 
/*---------------------------------------------------------------------------*\
                       Class ParticleZoneInfo Declaration
\*---------------------------------------------------------------------------*/
 
template<class CloudType>
class ParticleZoneInfo
:
    public CloudFunctionObject<CloudType>,
    public functionObjects::writeFile
 
{
    // Private Data
 
        // Typedefs
 
            //- Convenience typedef for parcel type
            typedef typename CloudType::parcelType parcelType;
 
 
        //- Cell zone name
        word cellZoneName_;
 
        //- Cell zone index
        label cellZoneId_;
 
        //- Stored data
        DynamicList<particleInfo> data_;
 
        //- Work storage
        DynamicList<particleInfo> movedParticles_;
 
        //- Maximum particle ID per processor
        labelList maxIDs_;
 
        //- Set writer
        autoPtr<coordSetWriter> writerPtr_;
 
 
    // Private Member Functions
 
        //- Write output file header
        void writeFileHeader(Ostream& os) const;
 
        //- Return true if celli is in the cellZone
        bool inZone(const label celli) const;
 
        //- Return the index of the particle in the storage (data_)
        //- Returns -1 if not found
        label getParticleID(const particleInfo& p) const;
 
        //- Write fields using writerPtr_
        void writeWriter(const UList<particleInfo>& data);
 
 
public:
 
    //- Runtime type information
    TypeName("particleZoneInfo");
 
 
    // Constructors
 
        //- Construct from dictionary
        ParticleZoneInfo
        (
            const dictionary& dict,
            CloudType& owner,
            const word& modelName
        );
 
        //- Construct copy
        ParticleZoneInfo(const ParticleZoneInfo<CloudType>& pe);
 
        //- Construct and return a clone
        virtual autoPtr<CloudFunctionObject<CloudType>> clone() const
        {
            return autoPtr<CloudFunctionObject<CloudType>>
            (
                new ParticleZoneInfo<CloudType>(*this)
            );
        }
 
 
    //- Destructor
    virtual ~ParticleZoneInfo() = default;
 
 
    // Member Functions
 
        //- Pre-evolve hook
        virtual void preEvolve
        (
            const typename parcelType::trackingData& td
        );
 
        //- Post-evolve hook
        virtual void postEvolve
        (
            const typename parcelType::trackingData& td
        );
 
        //- Post-move hook
        virtual void postMove
        (
            parcelType& p,
            const scalar dt,
            const point& position0,
            bool& keepParticle
        );
 
        //- Write
        virtual void write();
};
 
 
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
} // End namespace Foam
 
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
#ifdef NoRepository
    #include "ParticleZoneInfo.C"
#endif
 
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
#endif
 
// ************************************************************************* //