src/meshTools/cellClassification/cellClassification.H

   1 /*---------------------------------------------------------------------------*\
   2   =========                 |
   3   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
   4    \\    /   O peration     |
   5     \\  /    A nd           | Copyright (C) 2004-2011 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
  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 Class
  25     Foam::cellClassification
  26
  27 Description
  28     'Cuts' a mesh with a surface.
  29
  30     Divides cells into three types
  31     - cut, i.e. any of the edges of the cell is split or any edge of the
  32       surface pierces any of the faces of the cell.
  33     - outside: cell can be reached by Meshwave from any of the supplied
  34                outside points (without crossing any cut cell)
  35     - inside:  all other.
  36
  37     Used in various meshing programs.
  38
  39     Has various utility functions to deal with 'features' on this level
  40     where the mesh still has all inside and outside cells.
  41
  42     \par Concepts
  43
  44     - point classification:
  45         - point used by meshType cells only
  46         - point used by non-meshType cells only
  47         - point used by both types ('mixed')
  48
  49     - hanging cells: meshType cells using mixed points only.
  50       These cells would have all their vertices on the surface when
  51       extracting the meshType cells.
  52
  53     - regionEdges: edges where the cells using it are of mixed type.
  54       Or more precise when walking around the edge and looking at the
  55       different types of the cells there are more than two regions with
  56       same type.
  57
  58     Seen from above:
  59     \verbatim
  60     Ok:
  61          A | A
  62            |
  63          --+---
  64            |
  65          B | B
  66
  67     Not ok:
  68          A | B
  69            |
  70         ---+---
  71            |
  72          B | A
  73     \endverbatim
  74
  75     because this latter situation would cause the surface after subsetting
  76     type A or B to be multiply connected across this edge. And also when
  77     snapping the edge end points to the surface it might cause some twisted
  78     faces if the surface is normal to the edge (and smoothing the surface
  79     would not help since the points on the edge would be 'pulled' from two
  80     different sides)
  81
  82     - regionPoints: like regionEdges but now for points.
  83       Points where subsetting the mesh would cause a multiply connected
  84       outside surface (connected across point, not edge)
  85
  86
  87 SourceFiles
  88     cellClassification.C
  89
  90 \*---------------------------------------------------------------------------*/
  91
  92 #ifndef cellClassification_H
  93 #define cellClassification_H
  94
  95 #include "pointField.H"
  96 #include "Map.H"
  97 #include "boolList.H"
  98 #include "labelList.H"
  99 #include "faceList.H"
 100
 101 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 102
 103 namespace Foam
 104 {
 105
 106 // Forward declaration of classes
 107 class triSurfaceSearch;
 108 class meshSearch;
 109 class polyMesh;
 110 class polyMesh;
 111 class primitiveMesh;
 112 class triSurface;
 113
 114 /*---------------------------------------------------------------------------*\
 115                            Class cellClassification Declaration
 116 \*---------------------------------------------------------------------------*/
 117
 118 class cellClassification
 119 :
 120     public labelList
 121 {
 122
 123 public:
 124
 125     // Public data types
 126
 127         //- Type of cell.
 128         enum cType
 129         {
 130             NOTSET,
 131             INSIDE,     // Inside of surface
 132             OUTSIDE,    // Outside ,,
 133             CUT         // cut by surface
 134         };
 135
 136
 137         //- Enumeration defining the whether points are use by cells of
 138         //  a certain type.
 139         enum pointStatus
 140         {
 141             UNSET,
 142             MESH,       // points used by meshType cells
 143             NONMESH,    //    ,,          non-mesh type cells
 144             MIXED       //    ,,          both types of cell
 145         };
 146
 147 private:
 148
 149     // Private data
 150
 151         //- Reference to mesh
 152         const polyMesh& mesh_;
 153
 154
 155     // Private Static Functions
 156
 157         //- Count number of occurrences of elem in list
 158         static label count(const labelList& elems, const label elem);
 159
 160     // Private Member Functions
 161
 162         //- Mark all faces intersected by or intersecting surface
 163         boolList markFaces(const triSurfaceSearch&) const;
 164
 165         //- Divide cells into cut/inside/outside by using MeshWave from cut
 166         //  faces. No check is done on whether outsidePts are in different
 167         //  domains.
 168         void markCells
 169         (
 170             const meshSearch& queryMesh,
 171             const boolList& piercedFace,
 172             const pointField& outsidePts
 173         );
 174
 175         //- Use cell status to classify points as being internal to meshType,
 176         //  internal to non-meshType or on border of both.
 177         void classifyPoints
 178         (
 179             const label meshType,
 180             const labelList& cellType,
 181             List<pointStatus>& pointSide
 182         ) const;
 183
 184         //- Return true if cell uses only points with status=mixed
 185         bool usesMixedPointsOnly
 186         (
 187             const List<pointStatus>&,
 188             const label cellI
 189         ) const;
 190
 191         //- Get faces (and its 'owner') inbetween cells of differing type
 192         // (meshType and non-meshType).
 193         void getMeshOutside(const label meshType, faceList&, labelList&) const;
 194
 195 public:
 196
 197     // Static data members
 198     ClassName("cellClassification");
 199
 200     // Constructors
 201
 202         //- Construct from mesh and surface and point(s) on outside
 203         cellClassification
 204         (
 205             const polyMesh& mesh,
 206             const meshSearch& meshQuery,
 207             const triSurfaceSearch& surfQuery,
 208             const pointField& outsidePoints
 209         );
 210
 211         //- Construct from mesh and type for every cell.
 212         //  Used to be able to reuse filling routines below.
 213         cellClassification(const polyMesh& mesh, const labelList& cellType);
 214
 215         //- Construct as copy
 216         cellClassification(const cellClassification&);
 217
 218
 219     // Member Functions
 220
 221         const polyMesh& mesh() const
 222         {
 223             return mesh_;
 224         }
 225
 226         label trimCutCells
 227         (
 228             const label nLayers,
 229             const label meshType,
 230             const label fillType
 231         );
 232
 233         //- Sets vertex neighbours of meshType cells to fillType
 234         label growSurface(const label meshType, const label fillType);
 235
 236         //- Find hanging cells (cells with all points on outside) and set their
 237         //  type to fillType.
 238         //  Iterate until nothing changed. Returns total number of cells
 239         //  changed (in all iterations)
 240         label fillHangingCells
 241         (
 242             const label meshType,
 243             const label fillType,
 244             const label maxIter
 245         );
 246
 247         //- Find regionEdges and fill one neighbour. Iterate until nothing
 248         //  changes. Returns total number of cells changed.
 249         label fillRegionEdges
 250         (
 251             const label meshType,
 252             const label fillType,
 253             const label maxIter
 254         );
 255
 256         //- Find regionPoints and fill all neighbours. Iterate until nothing
 257         //  changes. Returns total number of cells changed.
 258         label fillRegionPoints
 259         (
 260             const label meshType,
 261             const label fillType,
 262             const label maxIter
 263         );
 264
 265         //- Write statistics on cell types to Ostream
 266         void writeStats(Ostream& os) const;
 267
 268
 269     // Member Operators
 270
 271         void operator=(const cellClassification&);
 272
 273 };
 274
 275
 276 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 277
 278 } // End namespace Foam
 279
 280 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 281
 282 #endif
 283
 284 // ************************************************************************* //