| /*---------------------------------------------------------------------------*\ | |
| ========= | | |
| \\ / F ield | OpenFOAM: The Open Source CFD Toolbox | |
| \\ / O peration | Website: https://openfoam.org | |
| \\ / A nd | Copyright (C) 2023 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::TriPatchIntersection | |
| Description | |
| Patch intersection based on triangular faces. Intersects and combines two | |
| triangulated patches incrementally. The intersected surface is valid at | |
| every stage of the process. Failure to intersect does not produce a | |
| catastrophic error. Rather, it results in regions of the surface remaining | |
| associated with only one of the source or the target patch. | |
| SourceFiles | |
| TriPatchIntersection.C | |
| \*---------------------------------------------------------------------------*/ | |
| // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // | |
| namespace Foam | |
| { | |
| /*---------------------------------------------------------------------------*\ | |
| Class TriPatchIntersection Declaration | |
| \*---------------------------------------------------------------------------*/ | |
| template<class SrcPatchType, class TgtPatchType> | |
| class TriPatchIntersection | |
| : | |
| public PatchIntersection<SrcPatchType, TgtPatchType> | |
| { | |
| private: | |
| // Private Data | |
| // Points | |
| //- The source points | |
| DynamicField<point> srcPoints_; | |
| //- The source point normals | |
| DynamicField<vector> srcPointNormals_; | |
| //- The target points. Reference to base class data. | |
| DynamicField<point>& tgtPoints_; | |
| //- Point-point addressing. Facilitates quick point removal. | |
| // Instead of shuffling up, when points are combined this just | |
| // acts as a redirect. Everything gets resolved on clean. | |
| DynamicList<label> pointPoints_; | |
| // Edges | |
| //- The two triangles adjacent to each edge | |
| DynamicList<labelPair> edgeTris_; | |
| //- ... | |
| DynamicList<labelPair> intersectEdgeFaces_; | |
| //- ... | |
| DynamicList<labelPair> nonIntersectEdgeFaces_; | |
| // Tris | |
| //- The triangles' points | |
| DynamicList<triFace> triPoints_; | |
| //- The triangles' edges | |
| DynamicList<FixedList<label, 3>> triEdges_; | |
| //- The source patch face associated with each triangle. -1 if not | |
| // associated with a source face. | |
| DynamicList<label> triSrcFace_; | |
| //- The target patch face associated with each triangle. -1 if not | |
| // associated with a target face. | |
| DynamicList<label> triTgtFace_; | |
| //- The triangles constructed from each source patch face | |
| List<DynamicList<label>> srcFaceTris_; | |
| //- The triangles constructed from each target patch face | |
| List<DynamicList<label>> tgtFaceTris_; | |
| // Faces | |
| //- ... | |
| DynamicList<labelList> faceEdges_; | |
| // Removal | |
| //- Indices of triangles that have been removed. Prevents shuffling | |
| // up and re-allocation during intersection. Cleared out on clean. | |
| DynamicList<label> removedTris_; | |
| //- Indices of edges that have been removed. Prevents shuffling | |
| // up and re-allocation during intersection. Cleared out on clean. | |
| DynamicList<label> removedEdges_; | |
| // Front propagation | |
| //- The edges in the front along which the intersection propagates | |
| DynamicList<label> frontEdgeEdges_; | |
| //- Inverse of the above | |
| DynamicList<label> edgeFrontEdges_; | |
| // Insertion | |
| //- Indices of triangles considered candidates for insertion | |
| DynamicList<label> candidateTriTris_; | |
| //- Inverse of the above | |
| DynamicList<label> triCandidateTris_; | |
| // Marking | |
| //- Indices of triangles that have been "marked". Used for multiple | |
| // purposes. | |
| DynamicList<label> markedTriTris_; | |
| //- Inverse of the above | |
| DynamicList<label> triMarkedTris_; | |
| // Triangulation | |
| //- Triangulation engine | |
| polygonTriangulate polygonTriangulate_; | |
| // Polygon generation | |
| //- Star propagation engine | |
| star star_; | |
| // Debugging | |
| //- Iteration counter with which to number surface files | |
| label writei_; | |
| // Private Member Functions | |
| //- Check consistency of the mesh | |
| void checkPatchFace(const label patchFacei, const bool isSrc) const; | |
| void checkPatchEdge(const label patchFacei, const bool isSrc) const; | |
| void checkPatchFaces(const bool isSrc) const; | |
| //- Remove an edge | |
| void removeEdge(const label edgei); | |
| //- Remove a tri | |
| void removeTri(const label trii); | |
| //- Create a new triangle and return it's index | |
| label newTrii(); | |
| //- Create a new edge and return it's index | |
| label newEdgei(); | |
| //- Create a new point and return it's index | |
| label newPointi(); | |
| //- Return a point of a given triangle | |
| label triPoint(const label trii, const label triPointi) const; | |
| //- Return the points of a given triangle | |
| triFace triPoints(const label trii) const; | |
| //- Get the values on the points of a given triangle | |
| template <class Type> | |
| FixedList<Type, 3> triPointValues | |
| ( | |
| const label trii, | |
| const UList<Type> values | |
| ) const; | |
| //- Get a list indicating whether a tri "owns" it's edges; i.e., | |
| // whether they are numbered in the same order as the points | |
| FixedList<bool, 3> triOwns(const label trii) const; | |
| //- Get the shared point indices of another tri in a tri, or -1 if | |
| // the point is not shared | |
| FixedList<label, 3> triOtherTriPoints | |
| ( | |
| const label trii, | |
| const label otherTrii | |
| ) const; | |
| //- Get the shared edge indices of another tri in a tri, or -1 if | |
| // the point is not shared | |
| FixedList<label, 3> triOtherTriEdges | |
| ( | |
| const label trii, | |
| const label otherTrii | |
| ) const; | |
| //- Return the tri-edge-points for a given tri-edge | |
| edge triEdgePoints(const label trii, const label triEdgei) const; | |
| //- Return the edge-points for a given edge | |
| edge edgePoints(const label edgei) const; | |
| //- Return a point for the given patch face | |
| label patchFacePoint | |
| ( | |
| const label patchFacei, | |
| const label patchFacePointi, | |
| const bool isSrc | |
| ) const; | |
| //- Return the points for the given patch face | |
| triFace patchFacePoints | |
| ( | |
| const label patchFacei, | |
| const bool isSrc | |
| ) const; | |
| //- Get the values on the points of a given patch face | |
| template <class Type> | |
| FixedList<Type, 3> patchFacePointValues | |
| ( | |
| const label patchFacei, | |
| const bool isSrc, | |
| const UList<Type>& values | |
| ) const; | |
| //- Get a list indicating whether a patch face "owns" it's edges; i.e., | |
| // whether they are numbered in the same order as the points | |
| FixedList<bool, 3> patchFaceOwns | |
| ( | |
| const label patchFacei, | |
| const bool isSrc | |
| ) const; | |
| //- Get the shared point indices of another patch face in a patch face, | |
| // or -1 if the point is not shared | |
| FixedList<label, 3> patchFaceOtherPatchFacePoints | |
| ( | |
| const label patchFacei, | |
| const label otherPatchFacei, | |
| const bool isSrc | |
| ) const; | |
| //- Return a patch point for the given patch face | |
| label patchFacePatchPoint | |
| ( | |
| const label patchFacei, | |
| const label patchFacePointi, | |
| const bool isSrc | |
| ) const; | |
| //- Return the patch points for the given patch face | |
| triFace patchFacePatchPoints | |
| ( | |
| const label patchFacei, | |
| const bool isSrc | |
| ) const; | |
| //- Return a patch edge for the given patch face | |
| label patchFacePatchEdge | |
| ( | |
| const label patchFacei, | |
| const label patchFaceEdgei, | |
| const bool isSrc | |
| ) const; | |
| //- Return the patch edges for the given patch face | |
| triFace patchFacePatchEdges | |
| ( | |
| const label patchFacei, | |
| const bool isSrc | |
| ) const; | |
| //- Compute the patch edge that a given edge lies along | |
| label edgePatchEdge(const label edgei, const bool isSrc) const; | |
| //- Compute the patch edges that a given edge lies along | |
| labelPair edgePatchEdges(const label edgei) const; | |
| //- Add a tri. Return the new tri label. | |
| label addTri | |
| ( | |
| const triFace& pointis, | |
| const FixedList<label, 3>& edgeis, | |
| const label patchFacei, | |
| const bool isSrc | |
| ); | |
| //- Flip an edge | |
| void flipEdge(const label edgei); | |
| //- Return the signed distance squared of the given point outside of a | |
| // triangle's circumcircle. A negative value means the point is inside | |
| // the circle. | |
| scalar circumDistSqr(const label trii, const label pointi) const; | |
| //- Insert points into the given tri or edge. If an edge, points are to | |
| // be given in order along the edge. | |
| void insertPoints | |
| ( | |
| const label triOrEdgei, | |
| const bool isTri, | |
| const UList<label>& pointis, | |
| UList<label>& insertionEdgeis, | |
| const UList<label>& fixedEdgeis | |
| ); | |
| //- Return whether or not a point can be intersected with the other side | |
| bool pointCanIntersect(const label pointi) const; | |
| //- Return whether or not an edge can be intersected with the other side | |
| bool edgeCanIntersect(const label pointi) const; | |
| /* | |
| //- Snap points to points and edges between two tris | |
| // !!! Not a good idea. Gets tangled up. Need to snap entire faces. | |
| bool snapTris(const label srcTrii, const label tgtTrii); | |
| */ | |
| //- Snap points to points and edges between two patch faces | |
| void snapPatchFaceTris | |
| ( | |
| const label srcFacei, | |
| const label tgtFacei, | |
| const scalar snapTol | |
| ); | |
| //- Intersect two tris | |
| bool intersectTris(const label srcTrii, const label tgtTrii); | |
| //- Intersect the triangulations of the given patch faces | |
| void intersectPatchFaceTris | |
| ( | |
| const label srcFacei, | |
| const label tgtFacei | |
| ); | |
| //- Make the triangulations of the given patch faces conform | |
| bool conformPatchFaceTris | |
| ( | |
| const label patchFacei, | |
| const label otherPatchFacei, | |
| const bool isSrc | |
| ); | |
| //- Make the triangulations of the given patch faces conform | |
| bool conformPatchFaceTris | |
| ( | |
| const label srcFacei, | |
| const label tgtFacei | |
| ); | |
| //- Combine conformal parts of the given patch faces into intersection | |
| // faces | |
| bool combinePatchFaceTris(const label srcFacei, const label tgtFacei); | |
| //- Initialise the member data | |
| void initialise(const vectorField& srcPointNormals); | |
| //- Clean up removed tris and edges | |
| void clean(); | |
| //- Finalise the data in the base class | |
| void finalise(); | |
| //- Undo the finalise process so the intersection process can continue | |
| void unFinalise(); | |
| //- Write the current state of the surfaces for debugging purposes | |
| void write(); | |
| //- Write the current state of the given patch face triangulation for | |
| // debugging purposes | |
| void writePatchFace(const label patchFacei, const bool isSrc) const; | |
| public: | |
| // Runtime type information | |
| virtual word type() const | |
| { | |
| return "tri" + patchIntersection::typeName.capitalise(); | |
| } | |
| // Constructors | |
| //- Construct from a source and a target patch | |
| TriPatchIntersection | |
| ( | |
| const SrcPatchType& srcPatch, | |
| const TgtPatchType& tgtPatch, | |
| const scalar snapTol | |
| ); | |
| //- Construct from a source and a target patch, and specified source | |
| // point normals | |
| TriPatchIntersection | |
| ( | |
| const SrcPatchType& srcPatch, | |
| const vectorField& srcPointNormals, | |
| const TgtPatchType& tgtPatch, | |
| const scalar snapTol | |
| ); | |
| // Member Functions | |
| // Access | |
| //- ... | |
| inline const DynamicList<labelList>& faceEdges() const | |
| { | |
| return faceEdges_; | |
| } | |
| //- ... | |
| inline const DynamicList<labelPair>& intersectEdgeFaces() const | |
| { | |
| return intersectEdgeFaces_; | |
| } | |
| //- ... | |
| inline const DynamicList<labelPair>& nonIntersectEdgeFaces() const | |
| { | |
| return nonIntersectEdgeFaces_; | |
| } | |
| //- Destructor | |
| virtual ~TriPatchIntersection(); | |
| }; | |
| // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // | |
| } // End namespace Foam | |
| // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // | |
| // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // | |
| // ************************************************************************* // | |