src/OpenFOAM/meshes/primitiveMesh/primitivePatch/walkPatch.C

   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 Description
  26
  27 \*---------------------------------------------------------------------------*/
  28
  29 #include "walkPatch.H"
  30 #include "ListOps.H"
  31
  32 // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
  33
  34 defineTypeNameAndDebug(Foam::walkPatch, 0);
  35
  36 // * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
  37
  38 // Get other face using v0, v1 (in localFaces numbering). Or -1.
  39 Foam::label Foam::walkPatch::getNeighbour
  40 (
  41     const label faceI,
  42     const label fp,
  43     const label v0,
  44     const label v1
  45 ) const
  46 {
  47     const labelList& fEdges = pp_.faceEdges()[faceI];
  48
  49     const edgeList& edges = pp_.edges();
  50
  51
  52     label nbrEdgeI = -1;
  53
  54     // Shortcut: maybe faceEdges are sorted(?) in which case fEdges[fp] is
  55     // edge between v0 and v1.
  56     const edge& e = edges[fEdges[fp]];
  57
  58     if ((e[0] == v0 && e[1] == v1) || (e[0] == v1 && e[1] == v0))
  59     {
  60         // Correct edge.
  61         nbrEdgeI = fEdges[fp];
  62     }
  63     else
  64     {
  65         // Loop over all faceEdges.
  66         forAll(fEdges, i)
  67         {
  68             label edgeI = fEdges[i];
  69
  70             const edge& e = edges[edgeI];
  71
  72             if
  73             (
  74                 (e[0] == v0 && e[1] == v1)
  75              || (e[0] == v1 && e[1] == v0)
  76             )
  77             {
  78                 // Found edge on face which uses v0, v1.
  79                 nbrEdgeI = edgeI;
  80
  81                 break;
  82             }
  83         }
  84     }
  85
  86
  87     if (nbrEdgeI == -1)
  88     {
  89         FatalErrorIn("getNeighbour")
  90             << "Did not find edge on face " << faceI << " that uses vertices"
  91             << v0 << " and " << v1 << abort(FatalError);
  92     }
  93
  94
  95     // Get neighbouring face.
  96
  97     const labelList& eFaces = pp_.edgeFaces()[nbrEdgeI];
  98
  99     if (eFaces.size() == 1)
 100     {
 101         return -1;
 102     }
 103     else if (eFaces.size() == 2)
 104     {
 105         label nbrFaceI = eFaces[0];
 106
 107         if (nbrFaceI == faceI)
 108         {
 109             nbrFaceI = eFaces[1];
 110         }
 111
 112         return nbrFaceI;
 113     }
 114     else
 115     {
 116         FatalErrorIn("getNeighbour")
 117             << "Illegal surface on patch. Face " << faceI
 118             << " at vertices " << v0 << ',' << v1
 119             << " has fewer than 1 or more than 2 neighbours"
 120             << abort(FatalError);
 121         return -1;
 122     }
 123 }
 124
 125
 126 // Gets labels of changed faces and enterVertices on faces.
 127 // Returns labels of faces changed and enterVertices on them.
 128 void Foam::walkPatch::faceToFace
 129 (
 130     const labelList& changedFaces,
 131     const labelList& enterVerts,
 132
 133     labelList& nbrFaces,
 134     labelList& nbrEnterVerts
 135 )
 136 {
 137     nbrFaces.setSize(pp_.size());
 138     nbrEnterVerts.setSize(pp_.size());
 139     label changedI = 0;
 140
 141     forAll(changedFaces, i)
 142     {
 143         label faceI = changedFaces[i];
 144         label enterVertI = enterVerts[i];
 145
 146         if (!visited_[faceI])
 147         {
 148             // Do this face
 149             visited_[faceI] = true;
 150             visitOrder_.append(faceI);
 151
 152             const face& f = pp_.localFaces()[faceI];
 153
 154             label fp = findIndex(f, enterVertI);
 155
 156             indexInFace_.append(fp);
 157
 158             // Visit neighbouring faces in order, starting at fp.
 159             for (label i = 0; i < f.size(); i++)
 160             {
 161                 label fp1 = reverse_ ? f.rcIndex(fp) : f.fcIndex(fp);
 162                 label nbr = getNeighbour(faceI, fp, f[fp], f[fp1]);
 163
 164                 if
 165                 (
 166                     nbr != -1
 167                  && !visited_[nbr]
 168                  && faceZone_[nbr] == faceZone_[faceI]
 169                 )
 170                 {
 171                     nbrFaces[changedI] = nbr;
 172                     nbrEnterVerts[changedI] = f[fp];
 173                     changedI++;
 174                 }
 175
 176                 fp = fp1;
 177             }
 178         }
 179     }
 180
 181     nbrFaces.setSize(changedI);
 182     nbrEnterVerts.setSize(changedI);
 183 }
 184
 185
 186 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
 187
 188 // Construct from components
 189 Foam::walkPatch::walkPatch
 190 (
 191     const primitivePatch& pp,
 192     const labelList& faceZone,
 193     const bool reverse,
 194     const label faceI,
 195     const label enterVertI,
 196     boolList& visited
 197 )
 198 :
 199     pp_(pp),
 200     faceZone_(faceZone),
 201     reverse_(reverse),
 202     visited_(visited),
 203     visitOrder_(pp.size()),
 204     indexInFace_(pp.size())
 205 {
 206     // List of faces that have been visited in the current iteration.
 207     labelList changedFaces(1, faceI);
 208     // Corresponding list of entry vertices
 209     labelList enterVerts(1, enterVertI);
 210
 211     while (true)
 212     {
 213         labelList nbrFaces;
 214         labelList nbrEnterVerts;
 215
 216         faceToFace
 217         (
 218             changedFaces,
 219             enterVerts,
 220
 221             nbrFaces,
 222             nbrEnterVerts
 223         );
 224
 225
 226         if (nbrFaces.empty())
 227         {
 228             break;
 229         }
 230
 231         changedFaces = nbrFaces;
 232         enterVerts = nbrEnterVerts;
 233     }
 234
 235     visitOrder_.shrink();
 236     indexInFace_.shrink();
 237 }
 238
 239
 240 // ************************************************************************* //