src/dynamicMesh/dynamicTopoFvMesh/dynamicTopoFvMesh.H

   1 /*---------------------------------------------------------------------------*\
   2   =========                 |
   3   \\      /  F ield         | foam-extend: Open Source CFD
   4    \\    /   O peration     | Version:     3.2
   5     \\  /    A nd           | Web:         http://www.foam-extend.org
   6      \\/     M anipulation  | For copyright notice see file Copyright
   7 -------------------------------------------------------------------------------
   8 License
   9     This file is part of foam-extend.
  10
  11     foam-extend is free software: you can redistribute it and/or modify it
  12     under the terms of the GNU General Public License as published by the
  13     Free Software Foundation, either version 3 of the License, or (at your
  14     option) any later version.
  15
  16     foam-extend is distributed in the hope that it will be useful, but
  17     WITHOUT ANY WARRANTY; without even the implied warranty of
  18     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  19     General Public License for more details.
  20
  21     You should have received a copy of the GNU General Public License
  22     along with foam-extend.  If not, see <http://www.gnu.org/licenses/>.
  23
  24 Class
  25     dynamicTopoFvMesh
  26
  27 Description
  28     An implementation of dynamic changes to mesh-topology
  29
  30 Author
  31     Sandeep Menon
  32     University of Massachusetts Amherst
  33     All rights reserved
  34
  35 SourceFiles
  36     dynamicTopoFvMesh.C
  37     dynamicTopoFvMeshI.H
  38     dynamicTopoFvMeshCheck.C
  39     dynamicTopoFvMeshCoupled.C
  40     dynamicTopoFvMeshReOrder.C
  41     dynamicTopoFvMeshMapping.C
  42     edgeBisect.C
  43     edgeCollapse.C
  44     edgeSwap.C
  45
  46 \*---------------------------------------------------------------------------*/
  47
  48 #ifndef dynamicTopoFvMesh_H
  49 #define dynamicTopoFvMesh_H
  50
  51 #include "Switch.H"
  52 #include "tetMetric.H"
  53 #include "topoMapper.H"
  54 #include "DynamicField.H"
  55 #include "threadHandler.H"
  56 #include "dynamicFvMesh.H"
  57
  58 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
  59
  60 namespace Foam
  61 {
  62
  63 // Class forward declarations
  64 class eMesh;
  65 class Stack;
  66 class changeMap;
  67 class objectMap;
  68 class motionSolver;
  69 class convexSetAlgorithm;
  70 class lengthScaleEstimator;
  71 class subMeshLduAddressing;
  72
  73 template <class MeshType>
  74 class coupledInfo;
  75
  76 /*---------------------------------------------------------------------------*\
  77                       Class dynamicTopoFvMesh Declaration
  78 \*---------------------------------------------------------------------------*/
  79
  80 class dynamicTopoFvMesh
  81 :
  82     public dynamicFvMesh
  83 {
  84     // Private typedefs
  85
  86         typedef coupledInfo<dynamicTopoFvMesh> coupledMesh;
  87         typedef threadHandler<dynamicTopoFvMesh> meshHandler;
  88
  89     // Private enumerants
  90
  91         enum opType
  92         {
  93             TOTAL_MODIFICATIONS = 0,
  94             TOTAL_SWAPS         = 1,
  95             TOTAL_BISECTIONS    = 2,
  96             TOTAL_COLLAPSES     = 3,
  97             SURFACE_SWAPS       = 4,
  98             SURFACE_BISECTIONS  = 5,
  99             SURFACE_COLLAPSES   = 6,
 100             TOTAL_SLIVERS       = 7,
 101             TOTAL_OP_TYPES
 102         };
 103
 104     // Private data
 105
 106         //- Reference to base mesh
 107         const dynamicTopoFvMesh& baseMesh_;
 108
 109         //- Number of boundary patches
 110         label nPatches_;
 111
 112         //- Topology change flag
 113         bool topoChangeFlag_;
 114
 115         //- Is this a subMesh?
 116         Switch isSubMesh_;
 117
 118         //- Dynamic mesh dictionary
 119         IOdictionary dict_;
 120
 121         //- Should all options be mandatorily specified?
 122         //  Handy for first-time use.
 123         Switch mandatory_;
 124
 125         //- Mesh characteristics [2D/3D]
 126         bool twoDMesh_;
 127
 128         //- Edge refinement switch
 129         Switch edgeRefinement_;
 130
 131         //- Load motion solver
 132         Switch loadMotionSolver_;
 133
 134         //- Switch for cell-bandwidth reduction
 135         Switch bandWidthReduction_;
 136
 137         //- Coupled modification switch
 138         mutable Switch coupledModification_;
 139
 140         //- Sub-Mesh lduAddressing
 141         mutable subMeshLduAddressing* lduPtr_;
 142
 143         //- Specify the re-meshing interval
 144         label interval_;
 145
 146         //- Edge-mesh
 147         autoPtr<eMesh> eMeshPtr_;
 148
 149         //- Field mapper
 150         autoPtr<topoMapper> mapper_;
 151
 152         //- Mesh motion solver
 153         autoPtr<motionSolver> motionSolver_;
 154
 155         //- Length scale estimator
 156         autoPtr<lengthScaleEstimator> lengthEstimator_;
 157
 158         //- Lists that dynamically resize during topo-changes
 159         //   - Since resizes happen infrequently,
 160         //     scale up by 10% to save memory.
 161         //   - Current C++ standard doesn't
 162         //     support template typedefs,
 163         //     so this is a work-around
 164         template <class T>
 165         class resizable
 166         {
 167         public:
 168             typedef DynamicList<T, 0, 11, 10> ListType;
 169             typedef DynamicField<T, 0, 11, 10> FieldType;
 170         };
 171
 172         resizable<point>::FieldType oldPoints_, points_;
 173         resizable<face>::ListType faces_;
 174         resizable<label>::ListType owner_, neighbour_;
 175         resizable<cell>::ListType cells_;
 176         resizable<edge>::ListType edges_;
 177         resizable<labelList>::ListType pointEdges_;
 178         resizable<labelList>::ListType edgeFaces_, faceEdges_;
 179         resizable<scalar>::ListType lengthScale_;
 180
 181         //- Size information
 182         labelList oldPatchSizes_, patchSizes_;
 183         labelList oldPatchStarts_, patchStarts_;
 184         labelList oldEdgePatchSizes_, edgePatchSizes_;
 185         labelList oldEdgePatchStarts_, edgePatchStarts_;
 186         labelList oldPatchNMeshPoints_, patchNMeshPoints_;
 187         label nOldPoints_, nPoints_;
 188         label nOldEdges_, nEdges_;
 189         label nOldFaces_, nFaces_;
 190         label nOldCells_, nCells_;
 191         label nOldInternalFaces_, nInternalFaces_;
 192         label nOldInternalEdges_, nInternalEdges_;
 193
 194         //- Maps [Old-to-New]
 195         labelList reversePointMap_;
 196         labelList reverseEdgeMap_;
 197         labelList reverseFaceMap_;
 198         labelList reverseCellMap_;
 199
 200         //- Maps [New-to-Old]
 201         labelList pointMap_;
 202         labelList edgeMap_;
 203         labelList faceMap_;
 204         labelList cellMap_;
 205
 206         //- Maps for the renumbering of added entities
 207         Map<label> addedPointRenumbering_;
 208         Map<label> addedEdgeRenumbering_;
 209         Map<label> addedFaceRenumbering_;
 210         Map<label> addedCellRenumbering_;
 211         Map<label> addedFacePatches_;
 212         Map<label> addedEdgePatches_;
 213         Map<label> addedPointZones_;
 214         Map<label> addedFaceZones_;
 215         Map<label> addedCellZones_;
 216
 217         // Information for field-mapping
 218         Map<labelList> faceParents_;
 219         List<scalarField> faceWeights_;
 220         List<vectorField> faceCentres_;
 221
 222         Map<labelList> cellParents_;
 223         List<scalarField> cellWeights_;
 224         List<vectorField> cellCentres_;
 225
 226         // Information for mapPolyMesh
 227         List<objectMap> pointsFromPoints_;
 228         List<objectMap> facesFromPoints_;
 229         List<objectMap> facesFromEdges_;
 230         List<objectMap> facesFromFaces_;
 231         List<objectMap> cellsFromPoints_;
 232         List<objectMap> cellsFromEdges_;
 233         List<objectMap> cellsFromFaces_;
 234         List<objectMap> cellsFromCells_;
 235
 236         //- Maps to keep track of entities deleted after addition
 237         labelHashSet deletedPoints_;
 238         labelHashSet deletedEdges_;
 239         labelHashSet deletedFaces_;
 240         labelHashSet deletedCells_;
 241
 242         //- List of flipped faces
 243         labelHashSet flipFaces_;
 244
 245         //- Run-time statistics
 246         label maxModifications_;
 247         labelList statistics_;
 248
 249         //- Sliver exudation
 250         scalar sliverThreshold_;
 251         Map<scalar> thresholdSlivers_;
 252
 253         //- Specific to proximity-based refinement
 254         List<labelPair> slicePairs_;
 255
 256         //- 3D Mesh Flipping data
 257         label maxTetsPerEdge_;
 258         scalar swapDeviation_;
 259         Switch allowTableResize_;
 260         labelList noSwapPatchIDs_;
 261
 262         //- Stack-list of entities to be checked for topo-changes.
 263         List<Stack> entityStack_;
 264
 265         //- Support for multithreading
 266         autoPtr<IOmultiThreader> threader_;
 267
 268         // Pointer-list of thread-handlers
 269         PtrList<meshHandler> handlerPtr_;
 270
 271         // Entity mutexes used for synchronization
 272         // in multi-threaded reOrdering
 273         FixedList<Mutex, 4> entityMutex_;
 274
 275         // Local coupled patch information
 276         PtrList<coupledMesh> patchCoupling_;
 277
 278         // List of processors that this sub-domain talks to
 279         labelList procIndices_;
 280
 281         // Processor priority list
 282         labelList procPriority_;
 283
 284         // Sub-Mesh pointers
 285         PtrList<coupledMesh> sendMeshes_;
 286         PtrList<coupledMesh> recvMeshes_;
 287
 288     // Private Member Functions
 289
 290         //- Disallow default bitwise copy construct
 291         dynamicTopoFvMesh(const dynamicTopoFvMesh&);
 292
 293         //- Construct from components
 294         //- Used for subMeshes only.
 295         dynamicTopoFvMesh
 296         (
 297             const dynamicTopoFvMesh& mesh,
 298             const IOobject& io,
 299             const Xfer<pointField>& points,
 300             const Xfer<pointField>& oldPoints,
 301             const Xfer<edgeList>& edges,
 302             const Xfer<faceList>& faces,
 303             const Xfer<labelListList>& faceEdges,
 304             const Xfer<labelList>& owner,
 305             const Xfer<labelList>& neighbour,
 306             const labelList& faceStarts,
 307             const labelList& faceSizes,
 308             const labelList& edgeStarts,
 309             const labelList& edgeSizes,
 310             const wordList& patchNames,
 311             const dictionary& patchDict
 312         );
 313
 314         //- Disallow default bitwise assignment
 315         void operator=(const dynamicTopoFvMesh&);
 316
 317         // Perform a Delaunay test on an internal face
 318         bool testDelaunay(const label fIndex) const;
 319
 320         //- Quality metric for tetrahedra in 3D
 321         tetMetric::tetMetricReturnType tetMetric_;
 322
 323         // Compute mapping weights for modified entities
 324         void computeMapping
 325         (
 326             const scalar matchTol,
 327             const bool skipMapping,
 328             const bool mappingOutput,
 329             const label faceStart,
 330             const label faceSize,
 331             const label cellStart,
 332             const label cellSize
 333         );
 334
 335         // Static equivalent for multiThreading
 336         static void computeMappingThread(void *argument);
 337
 338         // Routine to invoke threaded mapping
 339         void threadedMapping
 340         (
 341             scalar matchTol,
 342             bool skipMapping,
 343             bool mappingOutput
 344         );
 345
 346         // Initialize mesh edges and related connectivity lists
 347         void initEdges();
 348
 349         // Load the mesh-quality metric from the library
 350         void loadMetric();
 351
 352         // Load the mesh-motion solver
 353         void loadMotionSolver();
 354
 355         // Load the field mapper
 356         void loadFieldMapper();
 357
 358         // Load the length scale estimator
 359         void loadLengthScaleEstimator();
 360
 361         // Initialize the threading environment
 362         void initializeThreadingEnvironment(const label specThreads = -1);
 363
 364         // Return if mesh is 2D
 365         inline bool is2D() const;
 366
 367         // Return if mesh is 3D
 368         inline bool is3D() const;
 369
 370         // Return a non-const reference to the lengthScaleEstimator
 371         inline lengthScaleEstimator& lengthEstimator();
 372
 373         // Return a const reference to the lengthScaleEstimator
 374         inline const lengthScaleEstimator& lengthEstimator() const;
 375
 376         // Return a const reference to the multiThreader
 377         inline const multiThreader& threader() const;
 378
 379         // Return a reference to the entity mutexes
 380         inline const Mutex& entityMutex(const label entity) const;
 381
 382         // Return the edge index for a provided edge
 383         inline label getEdgeIndex(const edge& edgeToCheck) const;
 384
 385         // Given a boundary face, pick out a boundary edge that
 386         // contains a triangular face.
 387         inline label getTriBoundaryEdge(const label fIndex) const;
 388
 389         // Given an input quad-face, determine checkEdges from mesh
 390         static void getCheckEdges
 391         (
 392             const label fIndex,
 393             const dynamicTopoFvMesh& mesh,
 394             changeMap& map,
 395             FixedList<edge,4>& checkEdge,
 396             FixedList<label,4>& checkEdgeIndex
 397         );
 398
 399         // Return length-scale at an face-location in the mesh [2D]
 400         scalar faceLengthScale(const label fIndex) const;
 401
 402         // Return length-scale at an edge-location in the mesh [3D]
 403         scalar edgeLengthScale(const label eIndex) const;
 404
 405         // Check for bisection
 406         inline bool checkBisection(const label index) const;
 407
 408         // Check for collapse
 409         inline bool checkCollapse(const label index) const;
 410
 411         // MultiThreaded topology modifier
 412         void threadedTopoModifier();
 413
 414         // 2D Edge-swapping engine
 415         static void swap2DEdges(void *argument);
 416
 417         // 3D Edge-swapping engine
 418         static void swap3DEdges(void *argument);
 419
 420         // Edge refinement engine
 421         static void edgeRefinementEngine(void *argument);
 422
 423         // Return the entity stack for a particular thread
 424         inline Stack& stack(const label threadID);
 425
 426         // Return the integer ID for a given thread
 427         inline label self() const;
 428
 429         // Initialize stacks
 430         inline void initStacks(const labelHashSet& entities);
 431
 432         // Initialize the coupled stack
 433         void initCoupledStack
 434         (
 435             const labelHashSet& entities,
 436             bool useEntities
 437         );
 438
 439         // Method to determine the boundary patch index for a given face
 440         inline label whichPatch(const label index) const;
 441
 442         // Method to determine the boundary patch index for a given edge
 443         inline label whichEdgePatch(const label index) const;
 444
 445         // Report or alter topo-modification status
 446         inline label& status(const label type);
 447
 448         // Method for the swapping of a quad-face in 2D
 449         const changeMap
 450         swapQuadFace
 451         (
 452             const label fIndex
 453         );
 454
 455         // Method for the bisection of a quad-face in 2D
 456         const changeMap
 457         bisectQuadFace
 458         (
 459             const label fIndex,
 460             const changeMap& masterMap,
 461             bool checkOnly = false,
 462             bool forceOp = false
 463         );
 464
 465         // Method for the collapse of a quad-face in 2D
 466         const changeMap
 467         collapseQuadFace
 468         (
 469             const label fIndex,
 470             label overRideCase = -1,
 471             bool checkOnly = false,
 472             bool forceOp = false
 473         );
 474
 475         // Method for the bisection of an edge in 3D
 476         const changeMap
 477         bisectEdge
 478         (
 479             const label eIndex,
 480             bool checkOnly = false,
 481             bool forceOp = false
 482         );
 483
 484         // Method for the collapse of an edge in 3D
 485         const changeMap
 486         collapseEdge
 487         (
 488             const label eIndex,
 489             label overRideCase = -1,
 490             bool checkOnly = false,
 491             bool forceOp = false
 492         );
 493
 494         // Slice the mesh at a particular location
 495         void sliceMesh(const labelPair& pointPair);
 496
 497         // Utility method to check for invalid face-bisection.
 498         bool checkBisection
 499         (
 500             const label fIndex,
 501             const label bFaceIndex,
 502             bool forceOp = false
 503         ) const;
 504
 505         // Utility method to check for invalid face-collapse.
 506         static bool checkCollapse
 507         (
 508             const dynamicTopoFvMesh& mesh,
 509             const labelList& triFaces,
 510             const FixedList<label,2>& c0BdyIndex,
 511             const FixedList<label,2>& c1BdyIndex,
 512             const FixedList<label,2>& pointIndex,
 513             const FixedList<point,2>& newPoint,
 514             const FixedList<point,2>& oldPoint,
 515             scalar& collapseQuality,
 516             const bool checkNeighbour,
 517             bool forceOp = false
 518         );
 519
 520         // Utility method to check for invalid edge-collapse.
 521         bool checkCollapse
 522         (
 523             const point& newPoint,
 524             const point& oldPoint,
 525             const label pointIndex,
 526             const label cellIndex,
 527             dynamicLabelList& cellsChecked,
 528             scalar& collapseQuality,
 529             bool forceOp = false
 530         ) const;
 531
 532         // Remove 2D sliver cells from the mesh
 533         void remove2DSlivers();
 534
 535         // Identify the sliver type in 3D
 536         const changeMap identifySliverType(const label cIndex) const;
 537
 538         // Remove sliver cells
 539         void removeSlivers();
 540
 541         // Insert the specified cell to the mesh
 542         label insertCell
 543         (
 544             const cell& newCell,
 545             const scalar lengthScale,
 546             const label zoneID = -1
 547         );
 548
 549         // Set fill-in mapping information for a particular cell
 550         void setCellMapping
 551         (
 552             const label cIndex,
 553             const labelList& mapCells,
 554             bool addEntry = true
 555         );
 556
 557         // Set fill-in mapping information for a particular face
 558         void setFaceMapping
 559         (
 560             const label fIndex,
 561             const labelList& mapFaces = labelList(0)
 562         );
 563
 564         // Remove the specified cells from the mesh
 565         const changeMap
 566         removeCells
 567         (
 568             const labelList& cList,
 569             const label patch,
 570             const word& rcName,
 571             bool checkOnly = false
 572         );
 573
 574         // Remove the specified cell from the mesh
 575         void removeCell
 576         (
 577             const label cIndex
 578         );
 579
 580         // Insert the specified face to the mesh
 581         label insertFace
 582         (
 583             const label patch,
 584             const face& newFace,
 585             const label newOwner,
 586             const label newNeighbour,
 587             const labelList& newFaceEdges,
 588             const label zoneID = -1
 589         );
 590
 591         // Remove the specified face from the mesh
 592         void removeFace
 593         (
 594             const label fIndex
 595         );
 596
 597         // Split a set of internal faces into boundary faces,
 598         // and add them to the specified patch.
 599         void splitInternalFaces
 600         (
 601             const label patchIndex,
 602             const labelList& internalFaces,
 603             const Map<bool>& cellColors
 604         );
 605
 606         // Merge a set of boundary faces into internal
 607         const changeMap
 608         mergeBoundaryFaces
 609         (
 610             const labelList& mergeFaces
 611         );
 612
 613         // Insert the specified edge to the mesh
 614         label insertEdge
 615         (
 616             const label patch,
 617             const edge& newEdge,
 618             const labelList& edgeFaces
 619         );
 620
 621         // Remove the specified edge from the mesh
 622         void removeEdge
 623         (
 624             const label eIndex
 625         );
 626
 627         // Insert the specified point to the mesh
 628         label insertPoint
 629         (
 630             const point& newPoint,
 631             const point& oldPoint,
 632             const labelList& mapPoints,
 633             const label zoneID = -1
 634         );
 635
 636         // Remove the specified point from the mesh
 637         void removePoint
 638         (
 639             const label pIndex
 640         );
 641
 642         // Utility method to build vertexHull for an edge [3D]
 643         void buildVertexHull
 644         (
 645             const label eIndex,
 646             labelList& vertexHull,
 647             const label checkIndex = 0
 648         ) const;
 649
 650         // Utility to check whether points of an edge lie on a boundary
 651         const FixedList<bool,2> checkEdgeBoundary(const label eIndex) const;
 652
 653         // Set a particular face index as flipped.
 654         inline void setFlip(const label fIndex);
 655
 656         // Utility method to compute the minimum quality of a vertex hull
 657         scalar computeMinQuality
 658         (
 659             const label eIndex,
 660             labelList& hullVertices
 661         ) const;
 662
 663         // Compute minQuality given addressing
 664         scalar computeMinQuality
 665         (
 666             const edge& edgeToCheck,
 667             const labelList& hullVertices,
 668             const UList<point>& points,
 669             bool closedRing = false
 670         ) const;
 671
 672         // Utility method to compute the quality of a vertex hull
 673         // around an edge after bisection.
 674         scalar computeBisectionQuality(const label eIndex) const;
 675
 676         // Check whether the given edge is on a bounding curve
 677         bool checkBoundingCurve
 678         (
 679             const label eIndex,
 680             const bool overRidePurityCheck = false,
 681             label* nProcCurves = NULL
 682         ) const;
 683
 684         // Allocate dynamic programming tables
 685         void initTables
 686         (
 687             labelList& m,
 688             PtrList<scalarListList>& Q,
 689             PtrList<labelListList>& K,
 690             PtrList<labelListList>& triangulations,
 691             const label checkIndex = -1
 692         ) const;
 693
 694         // Check triangulation quality for an edge index
 695         bool checkQuality
 696         (
 697             const label eIndex,
 698             const labelList& m,
 699             const PtrList<scalarListList>& Q,
 700             const scalar minQuality,
 701             const label checkIndex = 0
 702         ) const;
 703
 704         // Utility method to fill the dynamic programming tables
 705         bool fillTables
 706         (
 707             const label eIndex,
 708             scalar& minQuality,
 709             labelList& m,
 710             labelList& hullVertices,
 711             PtrList<scalarListList>& Q,
 712             PtrList<labelListList>& K,
 713             PtrList<labelListList>& triangulations,
 714             const label checkIndex = 0
 715         ) const;
 716
 717         // Fill tables given addressing
 718         void fillTables
 719         (
 720             const edge& edgeToCheck,
 721             const scalar minQuality,
 722             const label m,
 723             const labelList& hullVertices,
 724             const UList<point>& points,
 725             scalarListList& Q,
 726             labelListList& K,
 727             labelListList& triangulations
 728         ) const;
 729
 730         // Print out tables for debugging
 731         void printTables
 732         (
 733             const labelList& m,
 734             const PtrList<scalarListList>& Q,
 735             const PtrList<labelListList>& K,
 736             const label checkIndex = 0
 737         ) const;
 738
 739         // Remove the edge according to the swap sequence
 740         const changeMap
 741         removeEdgeFlips
 742         (
 743             const label eIndex,
 744             const scalar minQuality,
 745             const labelList& hullVertices,
 746             PtrList<scalarListList>& Q,
 747             PtrList<labelListList>& K,
 748             PtrList<labelListList>& triangulations,
 749             const label checkIndex = 0
 750         );
 751
 752         // Extract triangulations from the programming table
 753         void extractTriangulation
 754         (
 755             const label i,
 756             const label j,
 757             const labelListList& K,
 758             label& numTriangulations,
 759             labelListList& triangulations
 760         ) const;
 761
 762         // Identify the 3-2 swap from the triangulation sequence
 763         label identify32Swap
 764         (
 765             const label eIndex,
 766             const labelList& hullVertices,
 767             const labelListList& triangulations,
 768             bool output = false
 769         ) const;
 770
 771         // Check old-volumes for the configuration.
 772         bool checkTriangulationVolumes
 773         (
 774             const label eIndex,
 775             const labelList& hullVertices,
 776             const labelListList& triangulations
 777         ) const;
 778
 779         // Routine to check whether the triangulation at the
 780         // index lies on the boundary of the vertex ring.
 781         bool boundaryTriangulation
 782         (
 783             const label index,
 784             label& isolatedVertex,
 785             labelListList& triangulations
 786         ) const;
 787
 788         // Routine to perform 2-3 swaps
 789         const changeMap
 790         swap23
 791         (
 792             const label isolatedVertex,
 793             const label eIndex,
 794             const label triangulationIndex,
 795             const label numTriangulations,
 796             const labelListList& triangulations,
 797             const labelList& hullVertices,
 798             const labelList& hullFaces,
 799             const labelList& hullCells
 800         );
 801
 802         // Routine to perform 3-2 or 2-2 swaps
 803         const changeMap
 804         swap32
 805         (
 806             const label eIndex,
 807             const label triangulationIndex,
 808             const label numTriangulations,
 809             const labelListList& triangulations,
 810             const labelList& hullVertices,
 811             const labelList& hullFaces,
 812             const labelList& hullCells
 813         );
 814
 815         // Reorder points after a topology change
 816         void reOrderPoints
 817         (
 818             pointField& points,
 819             pointField& preMotionPoints,
 820             labelListList& pointZoneMap,
 821             bool threaded = false
 822         );
 823
 824         // Static equivalent for multi-threading
 825         static void reOrderPointsThread(void *argument);
 826
 827         // Reorder edges after a topology change
 828         void reOrderEdges
 829         (
 830             edgeList& edges,
 831             labelListList& edgeFaces,
 832             labelListList& faceEdges,
 833             bool threaded = false
 834         );
 835
 836         // Static equivalent for multi-threading
 837         static void reOrderEdgesThread(void *argument);
 838
 839         // Reorder faces in upper-triangular order after a topology change
 840         void reOrderFaces
 841         (
 842             faceList& faces,
 843             labelList& owner,
 844             labelList& neighbour,
 845             labelListList& faceEdges,
 846             labelListList& faceZoneFaceMap,
 847             bool threaded = false
 848         );
 849
 850         // Static equivalent for multi-threading
 851         static void reOrderFacesThread(void *argument);
 852
 853         // Reorder & renumber cells with bandwidth
 854         // reduction after a topology change
 855         void reOrderCells
 856         (
 857             labelListList& cellZoneMap,
 858             bool threaded = false
 859         );
 860
 861         // Static equivalent for multi-threading
 862         static void reOrderCellsThread(void *argument);
 863
 864         // Reorder the mesh in upper-triangular order,
 865         // and generate mapping information
 866         void reOrderMesh
 867         (
 868             pointField& points,
 869             pointField& preMotionPoints,
 870             edgeList& edges,
 871             faceList& faces,
 872             labelList& owner,
 873             labelList& neighbour,
 874             labelListList& faceEdges,
 875             labelListList& edgeFaces,
 876             labelListList& pointZoneMap,
 877             labelListList& faceZoneFaceMap,
 878             labelListList& cellZoneMap
 879         );
 880
 881         // Invoke reOrdering with multiple threads
 882         void threadedMeshReOrdering
 883         (
 884             pointField& points,
 885             pointField& preMotionPoints,
 886             edgeList& edges,
 887             faceList& faces,
 888             labelList& owner,
 889             labelList& neighbour,
 890             labelListList& faceEdges,
 891             labelListList& edgeFaces,
 892             labelListList& pointZoneMap,
 893             labelListList& faceZoneFaceMap,
 894             labelListList& cellZoneMap
 895         );
 896
 897         // Reset the mesh and generate mapping information
 898         bool resetMesh();
 899
 900         // Write out connectivity for an edge
 901         void writeEdgeConnectivity(const label eIndex) const;
 902
 903         // Output an entity as a VTK file
 904         void writeVTK
 905         (
 906             const word& name,
 907             const label entity,
 908             const label primitiveType = 3,
 909             const bool useOldConnectivity = false,
 910             const bool useOldPoints = false
 911         ) const;
 912
 913         // Output a list of entities as a VTK file
 914         void writeVTK
 915         (
 916             const word& name,
 917             const labelList& cList,
 918             const label primitiveType = 3,
 919             const bool useOldConnectivity = false,
 920             const bool useOldPoints = false,
 921             const UList<scalar>& scalField = UList<scalar>(),
 922             const UList<label>& lablField = UList<label>()
 923         ) const;
 924
 925         // Return the status report interval
 926         scalar reportInterval() const;
 927
 928         // Check the state of local connectivity lists
 929         void checkConnectivity(const label maxErrors = 0) const;
 930
 931         // Handle mesh slicing events.
 932         void handleMeshSlicing();
 933
 934         // Handle layer addition / removal events
 935         void handleLayerAdditionRemoval();
 936
 937         // Add cell layer above specified patch
 938         const changeMap addCellLayer(const label patchID);
 939
 940         // Remove cell layer above specified patch
 941         const changeMap removeCellLayer(const label patchID);
 942
 943         // Test an edge / face for proximity with other non-neighbouring faces.
 944         // Return the scalar distance to the nearest face.
 945         scalar testProximity
 946         (
 947             const label index,
 948             label& proximityFace
 949         ) const;
 950
 951         // Calculate the edge length-scale for the mesh
 952         void calculateLengthScale(bool dump = false);
 953
 954         // Fill buffers with length-scale info
 955         // and exchange across processors.
 956         void exchangeLengthBuffers();
 957
 958         // Implementing the fillTables operation for coupled edges
 959         bool coupledFillTables
 960         (
 961             const label eIndex,
 962             scalar& minQuality,
 963             labelList& m,
 964             PtrList<scalarListList>& Q,
 965             PtrList<labelListList>& K,
 966             PtrList<labelListList>& triangulations
 967         ) const;
 968
 969         // Initialize coupled weights calculation
 970         void initCoupledWeights();
 971
 972         // Additional mapping contributions for coupled entities
 973         void computeCoupledWeights
 974         (
 975             const label index,
 976             const label dimension,
 977             labelList& parents,
 978             scalarField& weights,
 979             vectorField& centres,
 980             bool output = false
 981         );
 982
 983         // Fetch length-scale info for processor entities
 984         scalar processorLengthScale(const label index) const;
 985
 986         // Method to determine whether the master entity is locally coupled
 987         bool locallyCoupledEntity
 988         (
 989             const label index,
 990             bool checkSlaves = false,
 991             bool checkProcs = true,
 992             bool checkFace = false
 993         ) const;
 994
 995         // Method to determine the locally coupled patch index
 996         label locallyCoupledEdgePatch(const label eIndex) const;
 997
 998         // Method to determine if the entity is on a processor boundary
 999         bool processorCoupledEntity
1000         (
1001             const label index,
1002             bool checkFace = false,
1003             bool checkEdge = false,
1004             bool checkPure = false,
1005             FixedList<label, 2>* patchLabels = NULL,
1006             FixedList<vector, 2>* patchNormals = NULL
1007         ) const;
1008
1009         // Read optional dictionary parameters
1010         void readOptionalParameters(bool reRead = false);
1011
1012         // Execute load balancing operations on the mesh
1013         void executeLoadBalancing(dictionary& balanceDict);
1014
1015         // Identify coupled patches.
1016         bool identifyCoupledPatches();
1017
1018         // Read coupled patch information from dictionary.
1019         void readCoupledPatches();
1020
1021         // Initialize coupled patch connectivity for topology modifications.
1022         static void initCoupledConnectivity(void *argument);
1023
1024         // Move coupled subMesh points
1025         void moveCoupledSubMeshes();
1026
1027         // Build a list of entities that need to be avoided
1028         // by regular topo-changes.
1029         void buildEntitiesToAvoid
1030         (
1031             labelHashSet& entities,
1032             bool checkSubMesh
1033         );
1034
1035         // Check whether the specified edge is a coupled master edge.
1036         bool isCoupledMaster(const label eIndex) const;
1037
1038         // Set coupled modification
1039         void setCoupledModification() const;
1040
1041         // Unset coupled modification
1042         void unsetCoupledModification() const;
1043
1044         // Insert the cells around the coupled master entity to the mesh
1045         const changeMap insertCells(const label mIndex);
1046
1047         // Handle topology changes for coupled patches
1048         void handleCoupledPatches(labelHashSet& entities);
1049
1050         // Synchronize topology operations across processors
1051         void syncCoupledPatches(labelHashSet& entities);
1052
1053         // Check the state of coupled boundaries
1054         bool checkCoupledBoundaries(bool report = true) const;
1055
1056         // Build patch sub-meshes for processor patches
1057         void buildProcessorPatchMeshes();
1058
1059         // Build patch sub-mesh for a specified processor
1060         void buildProcessorPatchMesh
1061         (
1062             coupledMesh& subMesh,
1063             Map<labelList>& commonCells
1064         );
1065
1066         // Build coupled maps for locally coupled patches
1067         void buildLocalCoupledMaps();
1068
1069         // Build coupled maps for coupled processor patches
1070         void buildProcessorCoupledMaps();
1071
1072         // Introduce a new processor patch to the mesh
1073         label createProcessorPatch(const label proc);
1074
1075         // If a patch is of processor type,
1076         // get the neighbouring processor ID
1077         label getNeighbourProcessor(const label patch) const;
1078
1079         // If the number of patches have changed during run-time,
1080         // reset boundaries with new processor patches
1081         void resetBoundaries();
1082
1083         // Initialize subMesh field transfers for mapping
1084         void initFieldTransfers
1085         (
1086             wordList& fieldTypes,
1087             List<wordList>& fieldNames,
1088             List<List<char> >& sendBuffer,
1089             List<List<char> >& recvBuffer
1090         );
1091
1092         // Synchronize field transfers for mapping
1093         void syncFieldTransfers
1094         (
1095             wordList& fieldTypes,
1096             List<wordList>& fieldNames,
1097             List<List<char> >& recvBuffer
1098         );
1099
1100         // Initialize coupled boundary ordering
1101         void initCoupledBoundaryOrdering
1102         (
1103             List<pointField>& centres,
1104             List<pointField>& anchors
1105         ) const;
1106
1107         // Synchronize coupled boundary ordering
1108         bool syncCoupledBoundaryOrdering
1109         (
1110             List<pointField>& centres,
1111             List<pointField>& anchors,
1112             labelListList& faceMaps,
1113             labelListList& rotations
1114         ) const;
1115
1116         // Set processor rank priority
1117         void initProcessorPriority();
1118
1119         // Check for processor priority
1120         template <class BinaryOp>
1121         inline bool priority
1122         (
1123             const label first,
1124             const BinaryOp& bop,
1125             const label second
1126         ) const;
1127
1128         // Dump cell-quality statistics
1129         bool meshQuality(bool outputOption);
1130
1131 public:
1132
1133     //- Runtime type information
1134     TypeName("dynamicTopoFvMesh");
1135
1136     // Constructors
1137
1138         //- Construct from existing IOobject
1139         explicit dynamicTopoFvMesh(const IOobject& io);
1140
1141     // Destructor
1142
1143         virtual ~dynamicTopoFvMesh();
1144
1145     // Member Functions
1146
1147         // Return custom lduAddressing
1148         virtual const lduAddressing& lduAddr() const;
1149
1150         // Update mesh corresponding to the given map
1151         virtual void updateMesh(const mapPolyMesh& mpm);
1152
1153         // Map all fields in time using a customized mapper
1154         virtual void mapFields(const mapPolyMesh& mpm) const;
1155
1156         // Update the mesh for motion / topology changes
1157         //  - Return true if topology changes have occurred
1158         virtual bool update();
1159 };
1160
1161
1162 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
1163
1164 } // End namespace Foam
1165
1166 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
1167
1168 #include "dynamicTopoFvMeshI.H"
1169
1170 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
1171
1172 #endif
1173
1174 // ************************************************************************* //