src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/dynamicTopoFvMesh.H

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