src/meshTools/searchableSurface/triSurfaceMesh.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     Foam::triSurfaceMesh
  26
  27 Description
  28     IOoject and searching on triSurface
  29
  30     Note: when constructing from dictionary has optional parameters:
  31         - scale     : scaling factor.
  32         - tolerance : relative tolerance for doing intersections
  33                       (see triangle::intersection)
  34
  35 SourceFiles
  36     triSurfaceMesh.C
  37
  38 \*---------------------------------------------------------------------------*/
  39
  40 #ifndef triSurfaceMesh_H
  41 #define triSurfaceMesh_H
  42
  43 #include "treeBoundBox.H"
  44 #include "searchableSurface.H"
  45 #include "objectRegistry.H"
  46 #include "indexedOctree.H"
  47 #include "treeDataTriSurface.H"
  48 #include "octreeDataTriSurfaceTreeLeaf.H"
  49 #include "treeDataEdge.H"
  50 #include "EdgeMap.H"
  51
  52 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
  53
  54 namespace Foam
  55 {
  56
  57 /*---------------------------------------------------------------------------*\
  58                            Class triSurfaceMesh Declaration
  59 \*---------------------------------------------------------------------------*/
  60
  61 class triSurfaceMesh
  62 :
  63     public searchableSurface,
  64     public objectRegistry,      // so we can store fields
  65     public triSurface
  66 {
  67 private:
  68
  69     // Private member data
  70
  71         //- Optional tolerance to use in searches
  72         scalar tolerance_;
  73
  74         //- Optional max tree depth of octree
  75         label maxTreeDepth_;
  76
  77         //- Search tree (triangles)
  78         mutable autoPtr<indexedOctree<treeDataTriSurface> > tree_;
  79
  80         //- Search tree for boundary edges.
  81         mutable autoPtr<indexedOctree<treeDataEdge> > edgeTree_;
  82
  83         //- Names of regions
  84         mutable wordList regions_;
  85
  86         //- Is surface closed
  87         mutable label surfaceClosed_;
  88
  89
  90     // Private Member Functions
  91
  92         ////- Helper: find instance of files without header
  93         //static word findRawInstance
  94         //(
  95         //    const Time&,
  96         //    const fileName&,
  97         //    const word&
  98         //);
  99
 100         //- Check file existence
 101         static const fileName& checkFile
 102         (
 103             const fileName& fName,
 104             const fileName& objectName
 105         );
 106
 107         //- Helper function for isSurfaceClosed
 108         static bool addFaceToEdge
 109         (
 110             const edge&,
 111             EdgeMap<label>&
 112         );
 113
 114         //- Check whether surface is closed without calculating any permanent
 115         //  addressing.
 116         bool isSurfaceClosed() const;
 117
 118         //- Steps to next intersection. Adds smallVec and starts tracking
 119         //  from there.
 120         static void getNextIntersections
 121         (
 122             const indexedOctree<treeDataTriSurface>& octree,
 123             const point& start,
 124             const point& end,
 125             const vector& smallVec,
 126             DynamicList<pointIndexHit, 1, 1>& hits
 127         );
 128
 129         //- Disallow default bitwise copy construct
 130         triSurfaceMesh(const triSurfaceMesh&);
 131
 132         //- Disallow default bitwise assignment
 133         void operator=(const triSurfaceMesh&);
 134
 135
 136 protected:
 137
 138         //- Calculate (number of)used points and their bounding box
 139         void calcBounds(boundBox& bb, label& nPoints) const;
 140
 141 public:
 142
 143     //- Runtime type information
 144     TypeName("triSurfaceMesh");
 145
 146
 147     // Constructors
 148
 149         //- Construct from triSurface
 150         triSurfaceMesh(const IOobject&, const triSurface&);
 151
 152         //- Construct read.
 153         triSurfaceMesh(const IOobject& io);
 154
 155         //- Construct from IO and dictionary (used by searchableSurface).
 156         //  Dictionary may contain a 'scale' entry (eg, 0.001: mm -> m)
 157         triSurfaceMesh
 158         (
 159             const IOobject& io,
 160             const dictionary& dict
 161         );
 162
 163
 164     // Destructor
 165
 166         virtual ~triSurfaceMesh();
 167
 168         //- Clear storage
 169         void clearOut();
 170
 171
 172     // Member Functions
 173
 174         //- Move points
 175         virtual void movePoints(const pointField&);
 176
 177         //- Demand driven construction of octree
 178         const indexedOctree<treeDataTriSurface>& tree() const;
 179
 180         //- Demand driven contruction of octree for boundary edges
 181         const indexedOctree<treeDataEdge>& edgeTree() const;
 182
 183
 184         // searchableSurface implementation
 185
 186             virtual const wordList& regions() const;
 187
 188             //- Whether supports volume type below. I.e. whether is closed.
 189             virtual bool hasVolumeType() const;
 190
 191             //- Range of local indices that can be returned.
 192             virtual label size() const
 193             {
 194                 return triSurface::size();
 195             }
 196
 197             //- Get representative set of element coordinates
 198             //  Usually the element centres (should be of length size()).
 199             virtual pointField coordinates() const;
 200
 201             virtual void findNearest
 202             (
 203                 const pointField& sample,
 204                 const scalarField& nearestDistSqr,
 205                 List<pointIndexHit>&
 206             ) const;
 207
 208             virtual void findLine
 209             (
 210                 const pointField& start,
 211                 const pointField& end,
 212                 List<pointIndexHit>&
 213             ) const;
 214
 215             virtual void findLineAny
 216             (
 217                 const pointField& start,
 218                 const pointField& end,
 219                 List<pointIndexHit>&
 220             ) const;
 221
 222             //- Get all intersections in order from start to end.
 223             virtual void findLineAll
 224             (
 225                 const pointField& start,
 226                 const pointField& end,
 227                 List<List<pointIndexHit> >&
 228             ) const;
 229
 230             //- From a set of points and indices get the region
 231             virtual void getRegion
 232             (
 233                 const List<pointIndexHit>&,
 234                 labelList& region
 235             ) const;
 236
 237             //- From a set of points and indices get the normal
 238             virtual void getNormal
 239             (
 240                 const List<pointIndexHit>&,
 241                 vectorField& normal
 242             ) const;
 243
 244             //- Determine type (inside/outside/mixed) for point. unknown if
 245             //  cannot be determined (e.g. non-manifold surface)
 246             virtual void getVolumeType
 247             (
 248                 const pointField&,
 249                 List<volumeType>&
 250             ) const;
 251
 252
 253         // Other
 254
 255             //- Set bounds of surface. Bounds currently set as list of
 256             //  bounding boxes. The bounds are hints to the surface as for
 257             //  the range of queries it can expect. faceMap/pointMap can be
 258             //  set if the surface has done any redistribution.
 259             virtual void distribute
 260             (
 261                 const List<treeBoundBox>&,
 262                 const bool keepNonLocal,
 263                 autoPtr<mapDistribute>& faceMap,
 264                 autoPtr<mapDistribute>& pointMap
 265             )
 266             {}
 267
 268             //- WIP. Store element-wise field.
 269             virtual void setField(const labelList& values);
 270
 271             //- WIP. From a set of hits (points and
 272             //  indices) get the specified field. Misses do not get set.
 273             virtual void getField
 274             (
 275                 const List<pointIndexHit>&,
 276                 labelList&
 277             ) const;
 278
 279
 280         // regIOobject implementation
 281
 282             bool writeData(Ostream&) const
 283             {
 284                 notImplemented("triSurfaceMesh::writeData(Ostream&) const");
 285
 286                 return false;
 287             }
 288
 289             //- Write using given format, version and compression
 290             virtual bool writeObject
 291             (
 292                 IOstream::streamFormat fmt,
 293                 IOstream::versionNumber ver,
 294                 IOstream::compressionType cmp
 295             ) const;
 296 };
 297
 298
 299 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 300
 301 } // End namespace Foam
 302
 303 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 304
 305 #endif
 306
 307 // ************************************************************************* //