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