applications/utilities/mesh/conversion/polyDualMesh/meshDualiser.H

   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 Class
  25     meshDualiser
  26
  27 Description
  28     Creates dual of polyMesh. Every point becomes a cell (or multiple cells
  29     for feature points), a walk around every edge creates faces between them.
  30
  31     Put all points you want in the final mesh into featurePoints;
  32     all edge(mid)s you want in the final mesh into featureEdges;
  33     all face(centre)s in faceFaces.
  34
  35     Usually to preserve boundaries:
  36         - all boundary faces are featureFaces
  37         - all edges and points inbetween different patches are
  38           featureEdges/points.
  39
  40     In same way you can also preserve internal faces (e.g. faceZones)
  41
  42 SourceFiles
  43     meshDualiser.C
  44
  45 \*---------------------------------------------------------------------------*/
  46
  47 #ifndef meshDualiser_H
  48 #define meshDualiser_H
  49
  50 #include "DynamicList.H"
  51 #include "PackedBoolList.H"
  52 #include "boolList.H"
  53 #include "typeInfo.H"
  54
  55 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
  56
  57 namespace Foam
  58 {
  59
  60 class polyMesh;
  61 class directTopoChange;
  62
  63 /*---------------------------------------------------------------------------*\
  64                            Class meshDualiser Declaration
  65 \*---------------------------------------------------------------------------*/
  66
  67 class meshDualiser
  68 {
  69     // Private data
  70
  71         const polyMesh& mesh_;
  72
  73         //- From point on cell to dual cell. Either single entry or
  74         //  one entry per pointCells
  75         labelListList pointToDualCells_;
  76
  77         //- From point to dual point (or -1 if not feature point).
  78         labelList pointToDualPoint_;
  79
  80         //- From cell to dual point. All cells become point
  81         labelList cellToDualPoint_;
  82
  83         //- From face to dual point (or -1 if not feature face)
  84         labelList faceToDualPoint_;
  85
  86         //- From edge to dual point (or -1 if not feature edge)
  87         labelList edgeToDualPoint_;
  88
  89
  90     // Private Member Functions
  91
  92         static void checkPolyTopoChange(const directTopoChange&);
  93
  94         static void dumpPolyTopoChange(const directTopoChange&, const fileName&);
  95
  96         //- Find dual cell given point and cell
  97         label findDualCell(const label cellI, const label pointI) const;
  98
  99         //- Helper function to generate dualpoints on all boundary edges
 100         //  emanating from (boundary & feature) point
 101         void generateDualBoundaryEdges
 102         (
 103             const PackedBoolList&,
 104             const label pointI,
 105             directTopoChange&
 106         );
 107
 108         //- Check that owner and neighbour of face have same dual cell
 109         bool sameDualCell
 110         (
 111             const label faceI,
 112             const label pointI
 113         ) const;
 114
 115         //- Add internal face
 116         label addInternalFace
 117         (
 118             const label masterPointI,
 119             const label masterEdgeI,
 120             const label masterFaceI,
 121
 122             const bool edgeOrder,
 123             const label dualCell0,
 124             const label dualCell1,
 125             const DynamicList<label>& verts,
 126             directTopoChange& meshMod
 127         ) const;
 128
 129         //- Add boundary face
 130         label addBoundaryFace
 131         (
 132             const label masterPointI,
 133             const label masterEdgeI,
 134             const label masterFaceI,
 135
 136             const label dualCellI,
 137             const label patchI,
 138             const DynamicList<label>& verts,
 139             directTopoChange& meshMod
 140         ) const;
 141
 142         //- Create internal faces walking around edge
 143         void createFacesAroundEdge
 144         (
 145             const bool splitFace,
 146             const PackedBoolList&,
 147             const label edgeI,
 148             const label startFaceI,
 149             directTopoChange&,
 150             boolList& doneEFaces
 151         ) const;
 152
 153         //- Create single internal face from internal face
 154         void createFaceFromInternalFace
 155         (
 156             const label faceI,
 157             label& fp,
 158             directTopoChange&
 159         ) const;
 160
 161         //- Creates boundary faces walking around point on patchI.
 162         void createFacesAroundBoundaryPoint
 163         (
 164             const label patchI,
 165             const label patchPointI,
 166             const label startFaceI,
 167             directTopoChange&,
 168             boolList& donePFaces            // pFaces visited
 169         ) const;
 170
 171         //- Disallow default bitwise copy construct
 172         meshDualiser(const meshDualiser&);
 173
 174         //- Disallow default bitwise assignment
 175         void operator=(const meshDualiser&);
 176
 177
 178 public:
 179
 180     //- Runtime type information
 181     ClassName("meshDualiser");
 182
 183
 184     // Constructors
 185
 186         //- Construct from mesh
 187         meshDualiser(const polyMesh&);
 188
 189
 190     // Member Functions
 191
 192         // Access
 193
 194             //- From point on cell to dual cell. Either single entry or
 195             //  one entry per pointCells.
 196             const labelListList& pointToDualCells() const
 197             {
 198                 return pointToDualCells_;
 199             }
 200
 201             //- From point to dual point (or -1 if not feature point).
 202             const labelList& pointToDualPoint() const
 203             {
 204                 return pointToDualPoint_;
 205             }
 206
 207             //- From cell to dual point (at cell centre). All cells become
 208             //  points.
 209             const labelList& cellToDualPoint() const
 210             {
 211                 return cellToDualPoint_;
 212             }
 213
 214             //- From face to dual point (at face centre; or -1 if not
 215             //  feature face).
 216             const labelList& faceToDualPoint() const
 217             {
 218                 return faceToDualPoint_;
 219             }
 220
 221             //- From edge to dual point (at edge mid; or -1 if not feature
 222             //  edge).
 223             const labelList& edgeToDualPoint() const
 224             {
 225                 return edgeToDualPoint_;
 226             }
 227
 228
 229         // Edit
 230
 231
 232             //- Insert all changes into meshMod to convert the polyMesh into
 233             //  its dual.
 234             //  featureFaces  : faces where we want a point at the face centre
 235             //  featureEdges  : edges           ,,                 edge mid
 236             //  featurePoints : points          ,,    point. Two variants:
 237             //      singleCellFeaturePoints : point becomes one dualcell.
 238             //          Use this for e.g. convex boundary points.
 239             //      multiCellFeaturePoints : one dualcell per original cell
 240             //          around point. Use this for e.g. concave boundary points
 241             //          since it prevents big concave boundary cells.
 242             void setRefinement
 243             (
 244                 const bool splitFace,
 245                 const labelList& featureFaces,
 246                 const labelList& featureEdges,
 247                 const labelList& singleCellFeaturePoints,
 248                 const labelList& multiCellFeaturePoints,
 249                 directTopoChange& meshMod
 250             );
 251 };
 252
 253 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 254
 255 } // End namespace Foam
 256
 257 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 258
 259 #endif
 260
 261 // ************************************************************************* //