applications/utilities/mesh/conversion/sammToFoam/createPolyCells.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 Description
  25     Create intermediate mesh files from SAMM files
  26
  27 \*---------------------------------------------------------------------------*/
  28
  29 #include "sammMesh.H"
  30
  31 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
  32
  33 void sammMesh::createPolyCells()
  34 {
  35     // loop through all cell faces and create connectivity. This will produce
  36     // a global face list and will describe all cells as lists of face labels
  37
  38     // count the maximum number of faces and set the size of the cellPolys_
  39     cellPolys_.setSize(cellShapes_.size());
  40
  41     label maxFaces = 0;
  42
  43     forAll (cellPolys_, cellI)
  44     {
  45         cell& curCell = cellPolys_[cellI];
  46
  47         curCell.setSize(cellFaces_[cellI].size());
  48
  49         forAll (curCell, fI)
  50         {
  51             curCell[fI] = -1;
  52         }
  53
  54         maxFaces += cellFaces_[cellI].size();
  55     }
  56
  57     Info << "Maximum possible number of faces in mesh: " << maxFaces << endl;
  58
  59     meshFaces_.setSize(maxFaces);
  60
  61     // set reference to point-cell addressing
  62     const labelListList& PointCells = pointCells();
  63
  64     bool found = false;
  65
  66     nInternalFaces_ = 0;
  67
  68     forAll(cellFaces_, cellI)
  69     {
  70         // Note:
  71         // Insertion cannot be done in one go as the faces need to be
  72         // added into the list in the increasing order of neighbour
  73         // cells.  Therefore, all neighbours will be detected first
  74         // and then added in the correct order.
  75
  76         const faceList& curFaces = cellFaces_[cellI];
  77
  78         // Record the neighbour cell
  79         labelList neiCells(curFaces.size(), -1);
  80
  81         // Record the face of neighbour cell
  82         labelList faceOfNeiCell(curFaces.size(), -1);
  83
  84         label nNeighbours = 0;
  85
  86         // For all faces ...
  87         forAll(curFaces, faceI)
  88         {
  89             // Skip faces that have already been matched
  90             if (cellPolys_[cellI][faceI] >= 0) continue;
  91
  92             found = false;
  93
  94             const face& curFace = curFaces[faceI];
  95
  96             // get the list of labels
  97             const labelList& curPoints = curFace;
  98
  99             // For all points
 100             forAll(curPoints, pointI)
 101             {
 102                 // get the list of cells sharing this point
 103                 const labelList& curNeighbours = PointCells[curPoints[pointI]];
 104
 105                 // For all neighbours
 106                 forAll(curNeighbours, neiI)
 107                 {
 108                     label curNei = curNeighbours[neiI];
 109
 110                     // reject neighbours with the lower label. This should
 111                     // also reject current cell.
 112                     if (curNei > cellI)
 113                     {
 114                         // get the list of search faces
 115                         const faceList& searchFaces = cellFaces_[curNei];
 116
 117                         forAll(searchFaces, neiFaceI)
 118                         {
 119                             if (searchFaces[neiFaceI] == curFace)
 120                             {
 121                                 // match!!
 122                                 found = true;
 123
 124                                 // Record the neighbour cell and face
 125                                 neiCells[faceI] = curNei;
 126                                 faceOfNeiCell[faceI] = neiFaceI;
 127                                 nNeighbours++;
 128
 129                                 break;
 130                             }
 131                         }
 132                         if (found) break;
 133                     }
 134                     if (found) break;
 135                 }
 136                 if (found) break;
 137             } // End of current points
 138         } // End of current faces
 139
 140         // Add the faces in the increasing order of neighbours
 141         for (label neiSearch = 0; neiSearch < nNeighbours; neiSearch++)
 142         {
 143             // Find the lowest neighbour which is still valid
 144             label nextNei = -1;
 145             label minNei = cellPolys_.size();
 146
 147             forAll (neiCells, ncI)
 148             {
 149                 if (neiCells[ncI] > -1 && neiCells[ncI] < minNei)
 150                 {
 151                     nextNei = ncI;
 152                     minNei = neiCells[ncI];
 153                 }
 154             }
 155
 156             if (nextNei > -1)
 157             {
 158                 // Add the face to the list of faces
 159                 meshFaces_[nInternalFaces_] = curFaces[nextNei];
 160
 161                 // Mark for owner
 162                 cellPolys_[cellI][nextNei] = nInternalFaces_;
 163
 164                 // Mark for neighbour
 165                 cellPolys_[neiCells[nextNei]][faceOfNeiCell[nextNei]] =
 166                     nInternalFaces_;
 167
 168                 // Stop the neighbour from being used again
 169                 neiCells[nextNei] = -1;
 170
 171                 // Increment number of faces counter
 172                 nInternalFaces_++;
 173             }
 174             else
 175             {
 176               FatalErrorIn("void starMesh::createPolyCells()")
 177                   << "Error in internal face insertion"
 178                   << abort(FatalError);
 179             }
 180         }
 181     }
 182
 183     // I won't reset the size of internal faces, because more faces will be
 184     // added in createPolyBoundary()
 185 }
 186
 187
 188 // ************************************************************************* //