src/solidModels/arbitraryCrack/faceCracker/detachFaceCracker_orig.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 // Pout << "addedPoints before point creation: " << addedPoints << endl;
 101
 102     // Create new points for face zone
 103     forAll (addedPoints, pointI)
 104     {
 105         if (addedPoints[pointI] < 0)
 106         {
 107             addedPoints[pointI] =
 108                 ref.setAction
 109                 (
 110                     polyAddPoint
 111                     (
 112                         points[mp[pointI]],        // point
 113                         mp[pointI],                // master point
 114                         -1,                        // zone ID
 115                         true                       // supports a cell
 116                     )
 117                 );
 118         }
 119     }
 120
 121     // Modify faces in the master zone and duplicate for the slave zone
 122
 123     const labelList& mf = zoneMesh[crackZoneID_.index()];
 124     const boolList& mfFlip = zoneMesh[crackZoneID_.index()].flipMap();
 125     const faceList& zoneFaces = masterFaceLayer.localFaces();
 126
 127     const faceList& faces = mesh.faces();
 128     const labelList& own = mesh.faceOwner();
 129     const labelList& nei = mesh.faceNeighbour();
 130
 131     forAll (mf, faceI)
 132     {
 133         const label curFaceID = mf[faceI];
 134
 135         // Build the face for the slave patch by renumbering
 136         const face oldFace = zoneFaces[faceI].reverseFace();
 137
 138         face newFace(oldFace.size());
 139
 140         forAll (oldFace, pointI)
 141         {
 142             newFace[pointI] = addedPoints[oldFace[pointI]];
 143         }
 144
 145         if (mfFlip[faceI])
 146         {
 147             // Face needs to be flipped for the master patch
 148             ref.setAction
 149             (
 150                 polyModifyFace
 151                 (
 152                     faces[curFaceID].reverseFace(), // modified face
 153                     curFaceID,                  // label of face being modified
 154                     nei[curFaceID],                 // owner
 155                     -1,                             // neighbour
 156                     true,                           // face flip
 157                     crackPatchID_.index(),          // patch for face
 158                     false,                          // remove from zone
 159                     crackZoneID_.index(),           // zone for face
 160                     !mfFlip[faceI]                  // face flip in zone
 161                 )
 162             );
 163
 164             // Add renumbered face into the slave patch
 165             ref.setAction
 166             (
 167                 polyAddFace
 168                 (
 169                     newFace,                        // face
 170                     own[curFaceID],                 // owner
 171                     -1,                             // neighbour
 172                     -1,                             // master point
 173                     -1,                             // master edge
 174                     curFaceID,                      // master face
 175                     false,                          // flip flux
 176                     crackPatchID_.index(),          // patch to add the face to
 177                     -1,                             // zone for face
 178                     false                           // zone flip
 179                 )
 180             );
 181         }
 182         else
 183         {
 184             // No flip
 185             ref.setAction
 186             (
 187                 polyModifyFace
 188                 (
 189                     faces[curFaceID],         // modified face
 190                     curFaceID,                // label of face being modified
 191                     own[curFaceID],           // owner
 192                     -1,                       // neighbour
 193                     false,                    // face flip
 194                     crackPatchID_.index(),    // patch for face
 195                     false,                    // remove from zone
 196                     crackZoneID_.index(),     // zone for face
 197                     mfFlip[faceI]             // face flip in zone
 198                 )
 199             );
 200
 201             // Add renumbered face into the slave patch
 202             ref.setAction
 203             (
 204                 polyAddFace
 205                 (
 206                     newFace,                        // face
 207                     nei[curFaceID],                 // owner
 208                     -1,                             // neighbour
 209                     -1,                             // master point
 210                     -1,                             // master edge
 211                     curFaceID,                      // master face
 212                     true,                           // flip flux
 213                     crackPatchID_.index(),          // patch to add the face to
 214                     -1,                             // zone for face
 215                     false                           // face flip in zone
 216                 )
 217             );
 218         }
 219     }
 220
 221     // Modify the remaining faces of the master cells to reconnect to the new
 222     // layer of faces.
 223
 224     // Algorithm: Go through all the cells of the master zone and make
 225     // a map of faces to avoid duplicates.  Do not insert the faces in
 226     // the master patch (as they have already been dealt with).  Make
 227     // a master layer point renumbering map, which for every point in
 228     // the master layer gives its new label. Loop through all faces in
 229     // the map and attempt to renumber them using the master layer
 230     // point renumbering map.  Once the face is renumbered, compare it
 231     // with the original face; if they are the same, the face has not
 232     // changed; if not, modify the face but keep all of its old
 233     // attributes (apart from the vertex numbers).
 234
 235     // Create the map of faces in the master cell layer
 236     const labelList& mc =
 237         mesh.faceZones()[crackZoneID_.index()].masterCells();
 238
 239     labelHashSet masterCellFaceMap(6*mc.size());
 240
 241     const cellList& cells = mesh.cells();
 242
 243     forAll (mc, cellI)
 244     {
 245         const labelList& curFaces = cells[mc[cellI]];
 246
 247         forAll (curFaces, faceI)
 248         {
 249             // Check if the face belongs to the master patch; if not add it
 250             if (zoneMesh.whichZone(curFaces[faceI]) != crackZoneID_.index())
 251             {
 252                 masterCellFaceMap.insert(curFaces[faceI]);
 253             }
 254         }
 255     }
 256
 257     // Extend the map to include first neighbours of the master cells to
 258     // deal with multiple corners.
 259     { // Protection and memory management
 260         // Make a map of master cells for quick reject
 261         labelHashSet mcMap(2*mc.size());
 262
 263         forAll (mc, mcI)
 264         {
 265             mcMap.insert(mc[mcI]);
 266         }
 267
 268         // Go through all the faces in the masterCellFaceMap.  If the
 269         // cells around them are not already used, add all of their
 270         // faces to the map
 271         const labelList mcf = masterCellFaceMap.toc();
 272
 273         forAll (mcf, mcfI)
 274         {
 275             // Do the owner side
 276             const label ownCell = own[mcf[mcfI]];
 277
 278             if (!mcMap.found(ownCell))
 279             {
 280                 // Cell not found. Add its faces to the map
 281                 const cell& curFaces = cells[ownCell];
 282
 283                 forAll (curFaces, faceI)
 284                 {
 285                     masterCellFaceMap.insert(curFaces[faceI]);
 286                 }
 287             }
 288
 289             // Do the neighbour side if face is internal
 290             if (mesh.isInternalFace(mcf[mcfI]))
 291             {
 292                 const label neiCell = nei[mcf[mcfI]];
 293
 294                 if (!mcMap.found(neiCell))
 295                 {
 296                     // Cell not found. Add its faces to the map
 297                     const cell& curFaces = cells[neiCell];
 298
 299                     forAll (curFaces, faceI)
 300                     {
 301                         masterCellFaceMap.insert(curFaces[faceI]);
 302                     }
 303                 }
 304             }
 305         }
 306     }
 307
 308     // Create the master layer point map
 309     Map<label> masterLayerPointMap(2*mp.size());
 310
 311     forAll (mp, pointI)
 312     {
 313         masterLayerPointMap.insert
 314         (
 315             mp[pointI],
 316             addedPoints[pointI]
 317         );
 318     }
 319
 320     // Grab the list of faces of the master layer
 321     const labelList masterCellFaces = masterCellFaceMap.toc();
 322
 323     forAll (masterCellFaces, faceI)
 324     {
 325         // Attempt to renumber the face using the masterLayerPointMap.
 326         // Missing point remain the same
 327
 328         const label curFaceID = masterCellFaces[faceI];
 329
 330         const face& oldFace = faces[curFaceID];
 331
 332         face newFace(oldFace.size());
 333
 334         bool changed = false;
 335
 336         forAll (oldFace, pointI)
 337         {
 338             if (masterLayerPointMap.found(oldFace[pointI]))
 339             {
 340                 changed = true;
 341
 342                 newFace[pointI] = masterLayerPointMap.find(oldFace[pointI])();
 343             }
 344             else
 345             {
 346                 newFace[pointI] = oldFace[pointI];
 347             }
 348         }
 349
 350         // If the face has changed, create a modification entry
 351         if (changed)
 352         {
 353             if (mesh.isInternalFace(curFaceID))
 354             {
 355                 ref.setAction
 356                 (
 357                     polyModifyFace
 358                     (
 359                         newFace,                    // face
 360                         curFaceID,                  // master face
 361                         own[curFaceID],             // owner
 362                         nei[curFaceID],             // neighbour
 363                         false,                      // flip flux
 364                         -1,                         // patch for face
 365                         false,                      // remove from zone
 366                         -1,                         // zone for face
 367                         false                       // face zone flip
 368                     )
 369                 );
 370             }
 371             else
 372             {
 373                 ref.setAction
 374                 (
 375                     polyModifyFace
 376                     (
 377                         newFace,                     // face
 378                         curFaceID,                   // master face
 379                         own[curFaceID],              // owner
 380                         -1,                          // neighbour
 381                         false,                       // flip flux
 382                         mesh.boundaryMesh().whichPatch(curFaceID), // patch
 383                         false,                        // remove from zone
 384                         -1,                           // zone for face
 385                         false                         // face zone flip
 386                     )
 387                 );
 388             }
 389         }
 390     }
 391
 392     // Break coupled (processor) faces
 393     forAll (coupledFacesToBreak_, faceI)
 394     {
 395         const label& curFaceID = coupledFacesToBreak_[faceI];
 396
 397         ref.setAction
 398         (
 399             polyModifyFace
 400             (
 401                 faces[curFaceID],            // face
 402                 curFaceID,                   // master face
 403                 own[curFaceID],              // owner
 404                 -1,                          // neighbour
 405                 false,                       // flip flux
 406                 crackPatchID_.index(),       // patch
 407                 false,                       // remove from zone
 408                 -1,                          // zone for face
 409                 false                        // face zone flip
 410             )
 411         );
 412     }
 413
 414     // Clear the faces to open list
 415     coupledFacesToBreak_.setSize(0);
 416
 417     if (debug)
 418     {
 419         Pout<< "void faceCracker::detachFaceCracker("
 420             << "polyTopoChange& ref) const "
 421             << " for object " << name() << " : "
 422             << "Finished detaching faces" << endl;
 423     }
 424 }
 425
 426
 427 // ************************************************************************* //