src/meshTools/edgeFaceCirculator/edgeFaceCirculator.H

   1 /*---------------------------------------------------------------------------*\
   2   =========                 |
   3   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
   4    \\    /   O peration     |
   5     \\  /    A nd           | Copyright (C) 1991-2009 OpenCFD Ltd.
   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 Class
  26     Foam::edgeFaceCirculator
  27
  28 Description
  29     Walks from starting face around edge.
  30
  31     Implicit description of edge:
  32     - face
  33     - index in face. edge is always between f[index] and f[index+1]
  34     - direction (cell to walk into)
  35
  36     -# Use in-place: \n
  37         @code
  38             edgeFaceCirculator circ(..);
  39             // Optionally rotate to beginning: circ.setCanonical();
  40
  41             // Walk
  42             do
  43             {
  44                 Info<< "face:" << circ.face() << endl;
  45                 ++circ;
  46             }
  47             while (circ != circ.end());
  48         @endcode
  49
  50     -# Use like STL iterator: \n
  51         @code
  52             edgeFaceCirculator circ(..);
  53             for
  54             (
  55                 edgeFaceCirculator iter = circ.begin();
  56                 iter != circ.end();
  57                 ++iter
  58             )
  59             {
  60                 Info<< "face:" << iter.face() << endl;
  61             }
  62         @endcode
  63
  64
  65 SourceFiles
  66     edgeFaceCirculator.C
  67
  68 \*---------------------------------------------------------------------------*/
  69
  70 #ifndef edgeFaceCirculator_H
  71 #define edgeFaceCirculator_H
  72
  73 #include "face.H"
  74 #include "ListOps.H"
  75
  76 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
  77
  78 namespace Foam
  79 {
  80
  81 // Forward declaration of classes
  82 class primitiveMesh;
  83
  84 /*---------------------------------------------------------------------------*\
  85                            Class edgeFaceCirculator Declaration
  86 \*---------------------------------------------------------------------------*/
  87
  88 class edgeFaceCirculator
  89 {
  90     // Static data members
  91
  92         //- end iterator
  93         static const edgeFaceCirculator endConstIter;
  94
  95
  96     // Private data
  97
  98         //- Mesh
  99         const primitiveMesh& mesh_;
 100
 101         //- Current face
 102         label faceLabel_;
 103
 104         //- Current side of face
 105         bool ownerSide_;
 106
 107         //- Edge (between index and index+1 on faces[faceLabel_]
 108         label index_;
 109
 110         //- Is boundary edge?
 111         bool isBoundaryEdge_;
 112
 113         //- Starting face so we know when to stop. Used when circulating over
 114         //  internal edges.
 115         label startFaceLabel_;
 116
 117
 118     // Private Member Functions
 119
 120         //- Set to end() iterator
 121         inline void setEnd();
 122
 123         //- Check and set faceLabel_ and ownerSide_
 124         inline void setFace(const label faceI, const label cellI);
 125
 126         //- Set faceLabel_ to be the other face on the cell that uses the
 127         //  edge.
 128         inline void otherFace(const label cellI);
 129
 130
 131 public:
 132
 133     // Constructors
 134
 135         //- Construct from components
 136         inline edgeFaceCirculator
 137         (
 138             const primitiveMesh& mesh,
 139             const label faceLabel,
 140             const bool ownerSide,
 141             const label index,
 142             const bool isBoundaryEdge
 143         );
 144
 145         //- Construct as copy
 146         inline edgeFaceCirculator(const edgeFaceCirculator&);
 147
 148
 149     // Member Functions
 150
 151         //- Helper: find index in face of edge or -1. Index is such that edge is
 152         //  between f[index] and f[index+1]
 153         inline static label getMinIndex
 154         (
 155             const face& f,
 156             const label v0,
 157             const label v1
 158         );
 159
 160         inline label faceLabel() const;
 161
 162         inline bool ownerSide() const;
 163
 164         inline label index() const;
 165
 166         //- Helper: get the neighbouring cell according to the ownerSide.
 167         //  Returns -1 if on neighbourside of boundary face.
 168         inline label cellLabel() const;
 169
 170         //- Helper: return true if normal of generated face points along
 171         //  edge from v0 to v1. (v0 and v1 have to be on edge)
 172         inline bool sameOrder(const label v0, const label v1) const;
 173
 174         //- Set edge to a unique state so different ones can be compared.
 175         //  Internal edge: minimum face index.
 176         //  Boundary edge: walk back until boundary face.
 177         inline void setCanonical();
 178
 179
 180     // Member Operators
 181
 182         inline void operator=(const edgeFaceCirculator& iter);
 183
 184         inline bool operator==(const edgeFaceCirculator& iter) const;
 185
 186         inline bool operator!=(const edgeFaceCirculator& iter) const;
 187
 188         //- Step to next face. Uses no edge addressing!
 189         inline edgeFaceCirculator& operator++();
 190
 191         //- iterator set to the beginning face. For internal edges this is
 192         //  the current face. For boundary edges this is the first boundary face
 193         //  reached from walking back (i.e. in opposite direction to ++)
 194         inline edgeFaceCirculator begin() const;
 195         inline edgeFaceCirculator cbegin() const;
 196
 197         //- iterator set to beyond the end of the walk.
 198         inline const edgeFaceCirculator& end() const;
 199         inline const edgeFaceCirculator& cend() const;
 200 };
 201
 202
 203 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 204
 205 } // End namespace Foam
 206
 207 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 208
 209 #include "edgeFaceCirculatorI.H"
 210
 211 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 212
 213 #endif
 214
 215 // ************************************************************************* //