data/src/meshTools/patchToPatch/intersection/intersectionPatchToPatch.H

/*---------------------------------------------------------------------------*\
  =========                 |
  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
   \\    /   O peration     | Website:  https://openfoam.org
    \\  /    A nd           | Copyright (C) 2021-2026 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::patchToPatches::intersection

Description
    Class to generate patchToPatch coupling geometry. A full geometric
    intersection is done between a face and those opposite, and coupling
    geometry is calculated accordingly.

SourceFiles
    intersection.C

\*---------------------------------------------------------------------------*/

#ifndef intersectionPatchToPatch_H
#define intersectionPatchToPatch_H

#include "patchToPatch.H"
#include "polygonTriangulate.H"
#include "triFaceList.H"
#include "triIntersectLocation.H"

// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //

namespace Foam
{
namespace patchToPatches
{

/*---------------------------------------------------------------------------*\
                          Class intersection Declaration
\*---------------------------------------------------------------------------*/

class intersection
:
    public patchToPatch
{
public:

    // Public Structures

        //- Structure to store the geometry associated with part of a patch
        //  face
        struct part
        {
            //- The area of this part
            vector area;

            //- The centre of this part
            point centre;

            //- Default construct
            part()
            :
                area(Zero),
                centre(pTraits<point>::nan)
            {}

            //- Default construct
            part(const zero&)
            :
                part()
            {}

            //- Construct from an area and a centre
            part(const vector& a, const point& c)
            :
                area(a),
                centre(c)
            {}

            //- Construct from a polygon
            template<class PointField>
            part(const PointField& ps)
            {
                const Tuple2<vector, point> areaAndCentre =
                    face::areaAndCentreStabilised(ps);

                area = areaAndCentre.first();
                centre = areaAndCentre.second();
            }

            //- Negate this part
            part operator-() const
            {
                return part(- area, centre);
            }

            //- Add another part to this one
            void operator+=(const part& p)
            {
                const scalar magArea = mag(area);
                const scalar magPArea = mag(p.area);

                area = area + p.area;

                centre =
                    magArea == 0 ? p.centre
                  : magPArea == 0 ? centre
                  : (magArea*centre + magPArea*p.centre)/(magArea + magPArea);
            }

            //- Subtract another part from this one
            void operator-=(const part& p)
            {
                this->operator+=(-p);
            }

            //- Equality comparison
            friend bool operator==(const part& a, const part& b)
            {
                return a.area == b.area && a.centre == b.centre;
            }

            //- Inequality comparison
            friend bool operator!=(const part& a, const part& b)
            {
                return !(a == b);
            }

            //- Output stream operator
            friend Ostream& operator<<(Ostream& os, const part& p)
            {
                return os << p.area << p.centre;
            }

            //- Input stream operator
            friend Istream& operator>>(Istream& is, part& p)
            {
                return is >> p.area >> p.centre;
            }
        };

        //- Structure to store the geometry associated with the coupling
        //  between parts of two patch faces
        struct couple
        :
            public part
        {
            //- The neighbour part
            part nbr;

            //- Default construct
            couple()
            :
                part(),
                nbr()
            {}

            //- Construct from a coupled pair of parts
            couple(const part& p, const part& nbrP)
            :
                part(p),
                nbr(nbrP)
            {}

            //- Equality comparison
            friend bool operator==(const couple& a, const couple& b)
            {
                return
                    static_cast<const part&>(a) == static_cast<const part&>(b)
                 && a.nbr == b.nbr;
            }

            //- Inequality comparison
            friend bool operator!=(const couple& a, const couple& b)
            {
                return !(a == b);
            }

            //- Output stream operator
            friend Ostream& operator<<(Ostream& os, const couple& c)
            {
                return os << static_cast<const part&>(c) << c.nbr;
            }

            //- Input stream operator
            friend Istream& operator>>(Istream& is, couple& c)
            {
                return is >> static_cast<part&>(c) >> c.nbr;
            }
        };


private:

    // Private Data

        // Geometry

            //- The coupling geometry for each source face
            List<DynamicList<couple>> srcCouples_;

            //- The proportion of the source faces that are coupled
            List<scalar> srcCoverage_;

            //- The non-coupled geometry associated with each source edge
            List<part> srcEdgeParts_;

            //- The non-coupled geometry associated with mismatch in each
            //  source face's couplings
            List<part> srcErrorParts_;

            //- The coupling geometry for each target face
            List<DynamicList<couple>> tgtCouples_;

            //- The proportion of the target faces that are coupled
            List<scalar> tgtCoverage_;


        //- Triangulation engine
        mutable polygonTriangulate triEngine_;


        // Workspace

            //- Source face triangulation points
            mutable List<triFaceList> srcTriPoints_;

            //- Source face triangulation edges
            mutable List<List<FixedList<label, 3>>> srcTriFaceEdges_;

            //- Target face triangulation points
            mutable List<triFaceList> tgtTriPoints_;

            //- Target face triangulation edges
            mutable List<List<FixedList<label, 3>>> tgtTriFaceEdges_;

            //- Source intersection points
            mutable DynamicList<point> ictSrcPoints_;

            //- Source intersection point normals
            mutable DynamicList<vector> ictSrcPointNormals_;

            //- Target intersection points
            mutable DynamicList<point> ictTgtPoints_;

            //- Intersection locations
            mutable DynamicList<triIntersect::location> ictPointLocations_;

            //- Source face edge parts
            DynamicList<part> srcFaceEdgePart_;

            //- Target face edge parts
            DynamicList<part> tgtFaceEdgePart_;

            //- Source face edge parts
            List<List<part>> srcFaceEdgeParts_;


        // Debugging

            //- Intersection points
            mutable DynamicList<point> debugPoints_;

            //- Intersection faces
            mutable DynamicList<labelList> debugFaces_;

            //- The source face associated with each intersection face
            mutable DynamicList<label> debugFaceSrcFaces_;

            //- The target face associated with each intersection face
            mutable DynamicList<label> debugFaceTgtFaces_;

            //- The side of the intersection each face is on; 1 is the source
            //  side, -1 is the target side, and 0 is a face that spans the
            //  intersection volume; e.g., an edge or error face.
            mutable DynamicList<label> debugFaceSides_;


    // Private Static Member Functions

        //- Return the values at the points of a tri face
        template<class Type>
        static FixedList<Type, 3> triPointValues
        (
            const triFace& t,
            const UList<Type>& values
        );


    // Private Member Functions

        //- Get the bound box for a source face
        virtual treeBoundBox srcBox
        (
            const face& srcFace,
            const pointField& srcPoints,
            const vectorField& srcPointNormals
        ) const;

        //- Intersect two faces
        virtual bool intersectFaces
        (
            const primitiveOldTimePatch& srcPatch,
            const vectorField& srcPointNormals,
            const vectorField& srcPointNormals0,
            const primitiveOldTimePatch& tgtPatch,
            const label srcFacei,
            const label tgtFacei
        );

        //- Initialise the workspace
        virtual void initialise
        (
            const primitiveOldTimePatch& srcPatch,
            const vectorField& srcPointNormals,
            const vectorField& srcPointNormals0,
            const primitiveOldTimePatch& tgtPatch
        );

        //- Finalise the intersection locally. Trims the local target patch
        //  so that only parts that actually intersect the source remain.
        //  Returns new-to-old map for trimming target-associated data.
        virtual labelList finaliseLocal
        (
            const primitiveOldTimePatch& srcPatch,
            const vectorField& srcPointNormals,
            const vectorField& srcPointNormals0,
            const primitiveOldTimePatch& tgtPatch
        );

        //- Send data that resulted from an intersection between the source
        //  patch and a distributed source-local-target patch back to the
        //  original target processes
        virtual void rDistributeTgt(const primitiveOldTimePatch& tgtPatch);

        //- Finalise the intersection
        virtual label finalise
        (
            const primitiveOldTimePatch& srcPatch,
            const vectorField& srcPointNormals,
            const vectorField& srcPointNormals0,
            const primitiveOldTimePatch& tgtPatch,
            const transformer& tgtToSrc
        );

        //- For each source face, the coupled target weights
        virtual tmpNrc<List<DynamicList<scalar>>> srcWeights() const;

        //- For each target face, the coupled source weights
        virtual tmpNrc<List<DynamicList<scalar>>> tgtWeights() const;


public:

    //- Runtime type information
    TypeName("intersection");


    // Static Data Members

        //- Extra debugging for intersections between specific faces. Named
        //  "intersectionSrcFace" and "intersectionTgtFace" respectively.
        static int debugSrcFacei, debugTgtFacei;


    // Static Member Functions

        //- Get the bound box for a source face
        static treeBoundBox srcBoxStatic
        (
            const face& srcFace,
            const pointField& srcPoints,
            const vectorField& srcPointNormals
        );


    // Constructors

        //- Construct from components
        intersection(const bool reverse);


    //- Destructor
    ~intersection();


    // Member Functions

        //- For each source face, the source and target areas for each
        //  target coupling
        inline const List<DynamicList<couple>>& srcCouples() const;

        //- For each source edge, the non-coupled geometry associated
        //  with its projection
        inline const List<part>& srcEdgeParts() const;

        //- For each source face, the area associated with mismatch
        //  across the coupling
        inline const List<part>& srcErrorParts() const;

        //- For each target face, the target and source areas for each
        //  source coupling
        inline const List<DynamicList<couple>>& tgtCouples() const;

        //- Return the proportion of the source faces that are coupled
        inline const List<scalar>& srcCoverage() const;

        //- Return the proportion of the target faces that are coupled
        inline const List<scalar>& tgtCoverage() const;
};


// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //

} // End namespace patchToPatches
} // End namespace Foam

// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //

#include "intersectionPatchToPatchI.H"

// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //

#endif

// ************************************************************************* //