src/solidModels/arbitraryCrack/faceCracker/detachFaceCracker_firstFixNotRight.C

   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 \*---------------------------------------------------------------------------*/
  25
  26 #include "faceCracker.H"
  27 #include "polyMesh.H"
  28 #include "primitiveMesh.H"
  29 #include "polyTopoChange.H"
  30 #include "polyTopoChanger.H"
  31
  32 // * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
  33
  34 void Foam::faceCracker::detachFaceCracker
  35 (
  36     polyTopoChange& ref
  37 ) const
  38 {
  39     if (debug)
  40     {
  41         Pout<< "void faceCracker::detachFaceCracker("
  42             << "polyTopoChange& ref) const "
  43             << " for object " << name() << " : "
  44             << "Detaching faces" << endl;
  45     }
  46
  47     const polyMesh& mesh = topoChanger().mesh();
  48     const faceZoneMesh& zoneMesh = mesh.faceZones();
  49
  50     const primitiveFacePatch& masterFaceLayer =
  51         zoneMesh[crackZoneID_.index()]();
  52     const pointField& points = mesh.points();
  53     const labelListList& meshEdgeFaces = mesh.edgeFaces();
  54
  55     const labelList& mp = masterFaceLayer.meshPoints();
  56     const edgeList& zoneLocalEdges = masterFaceLayer.edges();
  57
  58     const labelList& meshEdges = zoneMesh[crackZoneID_.index()].meshEdges();
  59
  60     // Create the points
  61
  62     labelList addedPoints(mp.size(), -1);
  63
  64     // Go through boundary edges of the master patch.  If all the faces from
  65     // this patch are internal, mark the points in the addedPoints lookup
  66     // with their original labels to stop duplication
  67     label nIntEdges = masterFaceLayer.nInternalEdges();
  68
  69     for
  70     (
  71         label curEdgeID = nIntEdges;
  72         curEdgeID < meshEdges.size();
  73         curEdgeID++
  74     )
  75     {
  76         const labelList& curFaces = meshEdgeFaces[meshEdges[curEdgeID]];
  77
  78         bool edgeIsInternal = true;
  79
  80         forAll (curFaces, faceI)
  81         {
  82             if (!mesh.isInternalFace(curFaces[faceI]))
  83             {
  84                 // The edge belongs to a boundary face
  85                 edgeIsInternal = false;
  86                 break;
  87             }
  88         }
  89
  90         if (edgeIsInternal)
  91         {
  92             // Reset the point creation
  93             addedPoints[zoneLocalEdges[curEdgeID].start()] =
  94                 mp[zoneLocalEdges[curEdgeID].start()];
  95
  96             addedPoints[zoneLocalEdges[curEdgeID].end()] =
  97                 mp[zoneLocalEdges[curEdgeID].end()];
  98         }
  99     }
 100
 101     // Create new points for face zone
 102     forAll (addedPoints, pointI)
 103     {
 104         if (addedPoints[pointI] < 0)
 105         {
 106             addedPoints[pointI] =
 107                 ref.setAction
 108                 (
 109                     polyAddPoint
 110                     (
 111                         points[mp[pointI]],        // point
 112                         mp[pointI],                // master point
 113                         -1,                        // zone ID
 114                         true                       // supports a cell
 115                     )
 116                 );
 117         }
 118     }
 119
 120     // Modify faces in the master zone and duplicate for the slave zone
 121
 122     const labelList& mf = zoneMesh[crackZoneID_.index()];
 123     const boolList& mfFlip = zoneMesh[crackZoneID_.index()].flipMap();
 124     const faceList& zoneFaces = masterFaceLayer.localFaces();
 125
 126     const faceList& faces = mesh.faces();
 127     const labelList& own = mesh.faceOwner();
 128     const labelList& nei = mesh.faceNeighbour();
 129
 130     forAll (mf, faceI)
 131     {
 132         const label curFaceID = mf[faceI];
 133
 134         // Build the face for the slave patch by renumbering
 135         const face oldFace = zoneFaces[faceI].reverseFace();
 136
 137         face newFace(oldFace.size());
 138
 139         forAll (oldFace, pointI)
 140         {
 141             newFace[pointI] = addedPoints[oldFace[pointI]];
 142         }
 143
 144         if (mfFlip[faceI])
 145         {
 146             // Face needs to be flipped for the master patch
 147             ref.setAction
 148             (
 149                 polyModifyFace
 150                 (
 151                     faces[curFaceID].reverseFace(), // modified face
 152                     curFaceID,                  // label of face being modified
 153                     nei[curFaceID],                 // owner
 154                     -1,                             // neighbour
 155                     true,                           // face flip
 156                     crackPatchID_.index(),          // patch for face
 157                     false,                          // remove from zone
 158                     crackZoneID_.index(),           // zone for face
 159                     !mfFlip[faceI]                  // face flip in zone
 160                 )
 161             );
 162
 163             // Add renumbered face into the slave patch
 164             ref.setAction
 165             (
 166                 polyAddFace
 167                 (
 168                     newFace,                        // face
 169                     own[curFaceID],                 // owner
 170                     -1,                             // neighbour
 171                     -1,                             // master point
 172                     -1,                             // master edge
 173                     curFaceID,                      // master face
 174                     false,                          // flip flux
 175                     crackPatchID_.index(),          // patch to add the face to
 176                     -1,                             // zone for face
 177                     false                           // zone flip
 178                 )
 179             );
 180         }
 181         else
 182         {
 183             // No flip
 184             ref.setAction
 185             (
 186                 polyModifyFace
 187                 (
 188                     faces[curFaceID],         // modified face
 189                     curFaceID,                // label of face being modified
 190                     own[curFaceID],           // owner
 191                     -1,                       // neighbour
 192                     false,                    // face flip
 193                     crackPatchID_.index(),    // patch for face
 194                     false,                    // remove from zone
 195                     crackZoneID_.index(),     // zone for face
 196                     mfFlip[faceI]             // face flip in zone
 197                 )
 198             );
 199
 200             // Add renumbered face into the slave patch
 201             ref.setAction
 202             (
 203                 polyAddFace
 204                 (
 205                     newFace,                        // face
 206                     nei[curFaceID],                 // owner
 207                     -1,                             // neighbour
 208                     -1,                             // master point
 209                     -1,                             // master edge
 210                     curFaceID,                      // master face
 211                     true,                           // flip flux
 212                     crackPatchID_.index(),          // patch to add the face to
 213                     -1,                             // zone for face
 214                     false                           // face flip in zone
 215                 )
 216             );
 217         }
 218     }
 219
 220     // Modify the remaining faces of the master cells to reconnect to the new
 221     // layer of faces.
 222
 223     // Algorithm: Go through all the cells of the master zone and make
 224     // a map of faces to avoid duplicates.  Do not insert the faces in
 225     // the master patch (as they have already been dealt with).  Make
 226     // a master layer point renumbering map, which for every point in
 227     // the master layer gives its new label. Loop through all faces in
 228     // the map and attempt to renumber them using the master layer
 229     // point renumbering map.  Once the face is renumbered, compare it
 230     // with the original face; if they are the same, the face has not
 231     // changed; if not, modify the face but keep all of its old
 232     // attributes (apart from the vertex numbers).
 233
 234
 235     // Create the map of faces in the master cell layer
 236     // Bug-fix: PC, HJ and ZT, 19 Feb 2013
 237
 238     labelHashSet masterCellFaceMap(12*mf.size());
 239
 240     const labelListList& pointFaces = mesh.pointFaces();
 241
 242     forAll(mf, faceI)
 243     {
 244         const labelList& curFacePoints = faces[mf[faceI]];
 245
 246         forAll(curFacePoints, pointI)
 247         {
 248             const labelList& curPointFaces =
 249                 pointFaces[curFacePoints[pointI]];
 250
 251             forAll(curPointFaces, fI)
 252             {
 253                 if
 254                 (
 255                     zoneMesh.whichZone(curPointFaces[fI])
 256                  != crackZoneID_.index()
 257                 )
 258                 {
 259                     masterCellFaceMap.insert(curPointFaces[fI]);
 260                 }
 261             }
 262         }
 263     }
 264
 265
 266 //     // Create the map of faces in the master cell layer
 267 //     const labelList& mc =
 268 //         mesh.faceZones()[crackZoneID_.index()].masterCells();
 269
 270 //     labelHashSet masterCellFaceMap(6*mc.size());
 271
 272 //     const cellList& cells = mesh.cells();
 273
 274 //     forAll (mc, cellI)
 275 //     {
 276 //         const labelList& curFaces = cells[mc[cellI]];
 277
 278 //         forAll (curFaces, faceI)
 279 //         {
 280 //             // Check if the face belongs to the master patch; if not add it
 281 //             if (zoneMesh.whichZone(curFaces[faceI]) != crackZoneID_.index())
 282 //             {
 283 //                 masterCellFaceMap.insert(curFaces[faceI]);
 284 //             }
 285 //         }
 286 //     }
 287
 288 //     // Extend the map to include first neighbours of the master cells to
 289 //     // deal with multiple corners.
 290 //     { // Protection and memory management
 291 //         // Make a map of master cells for quick reject
 292 //         labelHashSet mcMap(2*mc.size());
 293
 294 //         forAll (mc, mcI)
 295 //         {
 296 //             mcMap.insert(mc[mcI]);
 297 //         }
 298
 299 //         // Go through all the faces in the masterCellFaceMap.  If the
 300 //         // cells around them are not already used, add all of their
 301 //         // faces to the map
 302 //         const labelList mcf = masterCellFaceMap.toc();
 303
 304 //         forAll (mcf, mcfI)
 305 //         {
 306 //             // Do the owner side
 307 //             const label ownCell = own[mcf[mcfI]];
 308
 309 //             if (!mcMap.found(ownCell))
 310 //             {
 311 //                 // Cell not found. Add its faces to the map
 312 //                 const cell& curFaces = cells[ownCell];
 313
 314 //                 forAll (curFaces, faceI)
 315 //                 {
 316 //                     masterCellFaceMap.insert(curFaces[faceI]);
 317 //                 }
 318 //             }
 319
 320 //             // Do the neighbour side if face is internal
 321 //             if (mesh.isInternalFace(mcf[mcfI]))
 322 //             {
 323 //                 const label neiCell = nei[mcf[mcfI]];
 324
 325 //                 if (!mcMap.found(neiCell))
 326 //                 {
 327 //                     // Cell not found. Add its faces to the map
 328 //                     const cell& curFaces = cells[neiCell];
 329
 330 //                     forAll (curFaces, faceI)
 331 //                     {
 332 //                         masterCellFaceMap.insert(curFaces[faceI]);
 333 //                     }
 334 //                 }
 335 //             }
 336 //         }
 337 //     }
 338
 339     // Create the master layer point map
 340     Map<label> masterLayerPointMap(2*mp.size());
 341
 342     forAll (mp, pointI)
 343     {
 344         masterLayerPointMap.insert
 345         (
 346             mp[pointI],
 347             addedPoints[pointI]
 348         );
 349     }
 350
 351     // Grab the list of faces of the master layer
 352     const labelList masterCellFaces = masterCellFaceMap.toc();
 353
 354     forAll (masterCellFaces, faceI)
 355     {
 356         // Attempt to renumber the face using the masterLayerPointMap.
 357         // Missing point remain the same
 358
 359         const label curFaceID = masterCellFaces[faceI];
 360
 361         const face& oldFace = faces[curFaceID];
 362
 363         face newFace(oldFace.size());
 364
 365         bool changed = false;
 366
 367         forAll (oldFace, pointI)
 368         {
 369             if (masterLayerPointMap.found(oldFace[pointI]))
 370             {
 371                 changed = true;
 372
 373                 newFace[pointI] = masterLayerPointMap.find(oldFace[pointI])();
 374             }
 375             else
 376             {
 377                 newFace[pointI] = oldFace[pointI];
 378             }
 379         }
 380
 381         // If the face has changed, create a modification entry
 382         if (changed)
 383         {
 384             if (mesh.isInternalFace(curFaceID))
 385             {
 386                 ref.setAction
 387                 (
 388                     polyModifyFace
 389                     (
 390                         newFace,                    // face
 391                         curFaceID,                  // master face
 392                         own[curFaceID],             // owner
 393                         nei[curFaceID],             // neighbour
 394                         false,                      // flip flux
 395                         -1,                         // patch for face
 396                         false,                      // remove from zone
 397                         -1,                         // zone for face
 398                         false                       // face zone flip
 399                     )
 400                 );
 401             }
 402             else
 403             {
 404                 ref.setAction
 405                 (
 406                     polyModifyFace
 407                     (
 408                         newFace,                     // face
 409                         curFaceID,                   // master face
 410                         own[curFaceID],              // owner
 411                         -1,                          // neighbour
 412                         false,                       // flip flux
 413                         mesh.boundaryMesh().whichPatch(curFaceID), // patch
 414                         false,                        // remove from zone
 415                         -1,                           // zone for face
 416                         false                         // face zone flip
 417                     )
 418                 );
 419             }
 420         }
 421     }
 422
 423     // Break coupled (processor) faces
 424     forAll (coupledFacesToBreak_, faceI)
 425     {
 426         const label& curFaceID = coupledFacesToBreak_[faceI];
 427
 428         ref.setAction
 429         (
 430             polyModifyFace
 431             (
 432                 faces[curFaceID],            // face
 433                 curFaceID,                   // master face
 434                 own[curFaceID],              // owner
 435                 -1,                          // neighbour
 436                 false,                       // flip flux
 437                 crackPatchID_.index(),       // patch
 438                 false,                       // remove from zone
 439                 -1,                          // zone for face
 440                 false                        // face zone flip
 441             )
 442         );
 443     }
 444
 445     // Clear the faces to open list
 446     coupledFacesToBreak_.setSize(0);
 447
 448     if (debug)
 449     {
 450         Pout<< "void faceCracker::detachFaceCracker("
 451             << "polyTopoChange& ref) const "
 452             << " for object " << name() << " : "
 453             << "Finished detaching faces" << endl;
 454     }
 455 }
 456
 457
 458 // ************************************************************************* //