PatchEdgeFaceWave.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) 2011-2016 OpenFOAM Foundation
    Copyright (C) 2020-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::PatchEdgeFaceWave
 
Description
    Wave propagation of information along patch. Every iteration
    information goes through one layer of faces. Templated on information
    that is transferred.
 
SourceFiles
    PatchEdgeFaceWave.C
 
\*---------------------------------------------------------------------------*/
 
#ifndef Foam_PatchEdgeFaceWave_H
#define Foam_PatchEdgeFaceWave_H
 
#include "bitSet.H"
#include "scalarField.H"
#include "primitivePatch.H"
#include "vectorTensorTransform.H"
 
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
namespace Foam
{
 
// Forward Declarations
class polyMesh;
 
/*---------------------------------------------------------------------------*\
                    Class PatchEdgeFaceWaveBase Declaration
\*---------------------------------------------------------------------------*/
 
class PatchEdgeFaceWaveBase
{
protected:
 
    // Protected Static Data
 
        //- Relative tolerance.
        //  Stop propagation if relative changes less than this tolerance
        //  (responsibility for checking this is up to Type implementation)
        static scalar propagationTol_;
 
 
    // Protected Data
 
        //- Reference to mesh
        const polyMesh& mesh_;
 
        //- Track if edge has changed
        bitSet changedEdge_;
 
        //- Track if face has changed
        bitSet changedFace_;
 
        //- List of changed edges
        DynamicList<label> changedEdges_;
 
        //- List of changed faces
        DynamicList<label> changedFaces_;
 
        //- Number of unvisited edges
        label nUnvisitedEdges_;
 
        //- Number of unvisited faces
        label nUnvisitedFaces_;
 
 
public:
 
    //- Default trackData value (for default template argument)
    static label dummyTrackData_;
 
 
    //- Runtime type information
    ClassName("PatchEdgeFaceWave");
 
 
    // Constructors
 
        //- Construct with mesh reference and set initial sizes
        PatchEdgeFaceWaveBase
        (
            const polyMesh& mesh,
            const label nEdges,
            const label nFaces
        );
 
 
    // Static Functions
 
        //- Access to propagation tolerance
        static scalar propagationTol() noexcept
        {
            return propagationTol_;
        }
 
        //- Change propagation tolerance, return previous value
        static scalar setPropagationTol(const scalar tol) noexcept
        {
            scalar old(propagationTol_);
            propagationTol_ = tol;
            return old;
        }
 
 
    // Member Functions
 
        //- Return access to the mesh
        const polyMesh& mesh() const noexcept { return mesh_; }
 
        //- Current number of changed edges
        label nChangedEdges() const noexcept { return changedEdges_.size(); }
 
        //- Current number of changed faces
        label nChangedFaces() const noexcept { return changedFaces_.size(); }
 
        //- Number of unvisited faces, i.e. faces that were not (yet)
        //- reached from walking across patch.
        //
        //  This can happen from
        //  - not enough iterations done
        //  - a disconnected patch
        //  - a patch without walls in it
        label nUnvisitedFaces() const noexcept { return nUnvisitedFaces_; }
 
        label nUnvisitedEdges() const noexcept { return nUnvisitedEdges_; }
};
 
 
/*---------------------------------------------------------------------------*\
                           Class PatchEdgeFaceWave Declaration
\*---------------------------------------------------------------------------*/
 
template
<
    class PrimitivePatchType,
    class Type,
    class TrackingData = label
>
class PatchEdgeFaceWave
:
    public PatchEdgeFaceWaveBase
{
    // Private Data
 
        //- Reference to patch
        const PrimitivePatchType& patch_;
 
        //- Wall information for all edges
        UList<Type>& allEdgeInfo_;
 
        //- Information on all patch faces
        UList<Type>& allFaceInfo_;
 
        //- Additional data to be passed into container
        TrackingData& td_;
 
        //- Number of evaluations
        label nEvals_;
 
        // Addressing between edges of patch_ and globalData.coupledPatch()
        labelList patchEdges_;
        labelList coupledEdges_;
        bitSet sameEdgeOrientation_;
 
 
    // Private Member Functions
 
        //- Updates edgeInfo with information from neighbour.
        //  Updates all statistics.
        bool updateEdge
        (
            const label edgeI,
            const label neighbourFacei,
            const Type& neighbourInfo,
            Type& edgeInfo
        );
 
        //- Updates faceInfo with information from neighbour.
        //  Updates all statistics.
        bool updateFace
        (
            const label facei,
            const label neighbourEdgeI,
            const Type& neighbourInfo,
            Type& faceInfo
        );
 
        //- Update coupled edges
        void syncEdges();
 
        //- No copy construct
        PatchEdgeFaceWave(const PatchEdgeFaceWave&) = delete;
 
        //- No copy assignment
        void operator=(const PatchEdgeFaceWave&) = delete;
 
 
public:
 
    // Constructors
 
        //- Construct from patch, list of changed edges with the Type
        //- for these edges.
        //  Obtains work arrays to operate on, one of size
        //  number of patch edges, the other number of patch faces.
        //  Iterates until nothing changes or maxIter reached.
        //  (maxIter can be 0)
        PatchEdgeFaceWave
        (
            const polyMesh& mesh,
            const PrimitivePatchType& patch,
            const labelList& initialEdges,
            const List<Type>& initialEdgesInfo,
            UList<Type>& allEdgeInfo,
            UList<Type>& allFaceInfo,
            const label maxIter,
            TrackingData& td = PatchEdgeFaceWaveBase::dummyTrackData_
        );
 
        //- Construct from patch.
        //  Use setEdgeInfo() and iterate() to do actual calculation
        PatchEdgeFaceWave
        (
            const polyMesh& mesh,
            const PrimitivePatchType& patch,
            UList<Type>& allEdgeInfo,
            UList<Type>& allFaceInfo,
            TrackingData& td = PatchEdgeFaceWaveBase::dummyTrackData_
        );
 
 
    // Member Functions
 
        //- Access allEdgeInfo
        UList<Type>& allEdgeInfo() const noexcept
        {
            return allEdgeInfo_;
        }
 
        //- Access allFaceInfo
        UList<Type>& allFaceInfo() const noexcept
        {
            return allFaceInfo_;
        }
 
        //- Additional data to be passed into container
        const TrackingData& data() const noexcept
        {
            return td_;
        }
 
        //- Copy initial data into allEdgeInfo_
        void setEdgeInfo
        (
            const labelUList& changedEdges,
            const UList<Type>& changedEdgesInfo
        );
 
        //- Propagate from edge to face.
        //  \return total number of faces (over all processors) changed.
        label edgeToFace();
 
        //- Propagate from face to edge.
        //  \return total number of edges (over all processors) changed.
        label faceToEdge();
 
        //- Iterate until no changes or maxIter reached.
        //  \return actual number of iterations.
        label iterate(const label maxIter);
};
 
 
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
//- Update operation
template
<
    class PrimitivePatchType,
    class Type,
    class TrackingData = int
>
class updateOp
{
    //- Additional data to be passed into container
    const polyMesh& mesh_;
    const PrimitivePatchType& patch_;
    const scalar tol_;
    TrackingData& td_;
 
public:
 
    updateOp
    (
        const polyMesh& mesh,
        const PrimitivePatchType& patch,
        const scalar tol,
        TrackingData& td
    )
    :
        mesh_(mesh),
        patch_(patch),
        tol_(tol),
        td_(td)
    {}
 
    void operator()(Type& x, const Type& y) const
    {
        if (y.valid(td_))
        {
            x.updateEdge(mesh_, patch_, y, true, tol_, td_);
        }
    }
};
 
 
//- Transform operation
template
<
    class PrimitivePatchType,
    class Type,
    class TrackingData = int
>
class transformOp
{
    //- Additional data to be passed into container
    const polyMesh& mesh_;
    const PrimitivePatchType& patch_;
    const scalar tol_;
    TrackingData& td_;
 
public:
 
    transformOp
    (
        const polyMesh& mesh,
        const PrimitivePatchType& patch,
        const scalar tol,
        TrackingData& td
    )
    :
        mesh_(mesh),
        patch_(patch),
        tol_(tol),
        td_(td)
    {}
 
    void operator()
    (
        const vectorTensorTransform& vt,
        const bool forward,
        UList<Type>& fld
    ) const
    {
        const tensor rot(forward ? vt.R() : vt.R().T());
 
        for (auto& val : fld)
        {
            val.transform(mesh_, patch_, rot, tol_, td_);
        }
    }
};
 
} // End namespace Foam
 
 
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
#ifdef NoRepository
    #include "PatchEdgeFaceWave.C"
#endif
 
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
#endif
 
// ************************************************************************* //