File size: 14,853 Bytes
5a600cf | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 | /*---------------------------------------------------------------------------*\
========= |
\\ / 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
\*---------------------------------------------------------------------------*/
#ifndef TriPatchIntersection_H
#define TriPatchIntersection_H
#include "PatchIntersection.H"
#include "star.H"
#include "polygonTriangulate.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
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
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#ifdef NoRepository
#include "TriPatchIntersection.C"
#endif
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#endif
// ************************************************************************* //
|