src/meshTools/meshSearch/meshSearch.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::meshSearch
  26
  27 Description
  28     Various (local, not parallel) searches on polyMesh;
  29     uses (demand driven) octree to search.
  30
  31 SourceFiles
  32     meshSearch.C
  33
  34 \*---------------------------------------------------------------------------*/
  35
  36 #ifndef meshSearch_H
  37 #define meshSearch_H
  38
  39 #include "pointIndexHit.H"
  40 #include "pointField.H"
  41
  42 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
  43
  44 namespace Foam
  45 {
  46
  47 // Forward declaration of classes
  48 class polyMesh;
  49 class treeDataCell;
  50 class treeDataFace;
  51 template<class Type> class indexedOctree;
  52
  53 /*---------------------------------------------------------------------------*\
  54                            Class meshSearch Declaration
  55 \*---------------------------------------------------------------------------*/
  56
  57 class meshSearch
  58 {
  59     // Private data
  60
  61         //- Reference to mesh
  62         const polyMesh& mesh_;
  63
  64         //- Whether to use face decomposition for all geometric tests
  65         const bool faceDecomp_;
  66
  67         //- demand driven octrees
  68
  69         mutable autoPtr<indexedOctree<treeDataFace> > boundaryTreePtr_;
  70         mutable autoPtr<indexedOctree<treeDataCell> > cellTreePtr_;
  71
  72
  73     // Private Member Functions
  74
  75         //- Updates nearestI, nearestDistSqr from any closer ones.
  76         static bool findNearer
  77         (
  78             const point& sample,
  79             const pointField& points,
  80             label& nearestI,
  81             scalar& nearestDistSqr
  82         );
  83
  84         //- Updates nearestI, nearestDistSqr from any selected closer ones.
  85         static bool findNearer
  86         (
  87             const point& sample,
  88             const pointField& points,
  89             const labelList& indices,
  90             label& nearestI,
  91             scalar& nearestDistSqr
  92         );
  93
  94
  95         // Cells
  96
  97             //- nearest cell centre using octree
  98             label findNearestCellTree(const point&) const;
  99
 100             //- nearest cell centre going through all cells
 101             label findNearestCellLinear(const point&) const;
 102
 103             //- walk from seed. Does not 'go around' boundary, just returns
 104             //  last cell before boundary.
 105             label findNearestCellWalk(const point&, const label) const;
 106
 107             //- cell containing location. Linear search.
 108             label findCellLinear(const point&) const;
 109
 110             //- walk from seed. Does not 'go around' boundary, just returns
 111             //  last cell before boundary.
 112             label findCellWalk(const point&, const label) const;
 113
 114
 115         // Faces
 116
 117             label findNearestFaceTree(const point&) const;
 118
 119             label findNearestFaceLinear(const point&) const;
 120
 121             label findNearestFaceWalk(const point&, const label) const;
 122
 123
 124
 125         // Boundary faces
 126
 127             //- walk from seed to find nearest boundary face. Gets stuck in
 128             //  local minimum.
 129             label findNearestBoundaryFaceWalk
 130             (
 131                 const point& location,
 132                 const label seedFaceI
 133             ) const;
 134
 135             //- Calculate offset vector in direction dir with as length a
 136             //  fraction of the cell size (of the cell straddling boundary face)
 137             vector offset
 138             (
 139                 const point& bPoint,
 140                 const label bFaceI,
 141                 const vector& dir
 142             ) const;
 143
 144
 145         //- Disallow default bitwise copy construct
 146         meshSearch(const meshSearch&);
 147
 148         //- Disallow default bitwise assignment
 149         void operator=(const meshSearch&);
 150
 151
 152 public:
 153
 154     // Declare name of the class and its debug switch
 155     ClassName("meshSearch");
 156
 157
 158     // Static data members
 159
 160         //- tolerance on linear dimensions
 161         static scalar tol_;
 162
 163
 164     // Constructors
 165
 166         //- Construct from components
 167         meshSearch(const polyMesh& mesh, const bool faceDecomp = true);
 168
 169
 170     //- Destructor
 171     ~meshSearch();
 172
 173
 174     // Member Functions
 175
 176         // Access
 177
 178             const polyMesh& mesh() const
 179             {
 180                 return mesh_;
 181             }
 182
 183             //- Get (demand driven) reference to octree holding all
 184             //  boundary faces
 185             const indexedOctree<treeDataFace>& boundaryTree() const;
 186
 187             //- Get (demand driven) reference to octree holding all cells
 188             const indexedOctree<treeDataCell>& cellTree() const;
 189
 190
 191         // Queries
 192
 193             //- test for point in cell. Does not handle cells with center
 194             //  outside cell.
 195             bool pointInCell(const point& p, const label celli) const;
 196
 197             //- Find nearest cell in terms of cell centre.
 198             //  Options:
 199             //  - use octree
 200             //  - use linear search
 201             //  - if seed is provided walk. (uses findNearestCellWalk;
 202             //    does not handle holes in domain)
 203             label findNearestCell
 204             (
 205                 const point& location,
 206                 const label seedCellI = -1,
 207                 const bool useTreeSearch = true
 208             ) const;
 209
 210             label findNearestFace
 211             (
 212                 const point& location,
 213                 const label seedFaceI = -1,
 214                 const bool useTreeSearch = true
 215             ) const;
 216
 217             //- Find cell containing (using pointInCell) location.
 218             //  If seed provided walks and falls back to linear/tree search.
 219             //  (so handles holes correctly)s
 220             //  Returns -1 if not in domain.
 221             label findCell
 222             (
 223                 const point& location,
 224                 const label seedCellI = -1,
 225                 const bool useTreeSearch = true
 226             ) const;
 227
 228             //- Find nearest boundary face
 229             //  If seed provided walks but then does not pass local minima
 230             //  in distance. Also does not jump from one connected region to
 231             //  the next.
 232             label findNearestBoundaryFace
 233             (
 234                 const point& location,
 235                 const label seedFaceI = -1,
 236                 const bool useTreeSearch = true
 237             ) const;
 238
 239             //- Find first intersection of boundary in segment [pStart, pEnd]
 240             //  (so inclusive of endpoints). Always octree for now
 241             pointIndexHit intersection(const point& pStart, const point& pEnd)
 242             const;
 243
 244             //- Find all intersections of boundary within segment pStart .. pEnd
 245             //  Always octree for now
 246             List<pointIndexHit> intersections
 247             (
 248                 const point& pStart,
 249                 const point& pEnd
 250             ) const;
 251
 252             //- Determine inside/outside status
 253             bool isInside(const point&) const;
 254
 255
 256         //- delete all storage
 257         void clearOut();
 258
 259         //- Correct for mesh geom/topo changes
 260         void correct();
 261 };
 262
 263
 264 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 265
 266 } // End namespace Foam
 267
 268 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 269
 270 #endif
 271
 272 // ************************************************************************* //