src/meshTools/searchableSurface/searchableSurface.H

   1 /*---------------------------------------------------------------------------*\
   2   =========                 |
   3   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
   4    \\    /   O peration     |
   5     \\  /    A nd           | Copyright held by original author
   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::searchableSurface
  27
  28 Description
  29     Base class of (analytical or triangulated) surface.
  30     Encapsulates all the search routines. WIP.
  31
  32     Information returned is usually a pointIndexHit:
  33     - bool  : was intersection/nearest found?
  34     - point : intersection point or nearest point
  35     - index : unique index on surface (e.g. triangle for triSurfaceMesh)
  36
  37 SourceFiles
  38     searchableSurface.C
  39
  40 \*---------------------------------------------------------------------------*/
  41
  42 #ifndef searchableSurface_H
  43 #define searchableSurface_H
  44
  45 #include "pointField.H"
  46 #include "typeInfo.H"
  47 #include "runTimeSelectionTables.H"
  48 #include "pointIndexHit.H"
  49 #include "linePointRef.H"
  50 #include "objectRegistry.H"
  51
  52 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
  53
  54 namespace Foam
  55 {
  56
  57 // Forward declaration of classes
  58 class objectRegistry;
  59 class mapDistribute;
  60 class treeBoundBox;
  61
  62 /*---------------------------------------------------------------------------*\
  63                            Class searchableSurface Declaration
  64 \*---------------------------------------------------------------------------*/
  65
  66 class searchableSurface
  67 :
  68     public regIOobject
  69 {
  70 public:
  71
  72     // Data types
  73
  74         //- volume types
  75         enum volumeType
  76         {
  77             UNKNOWN = 0,
  78             MIXED = 1,      // not used. only here to maintain consistency with
  79                             // indexedOctree volumeType.
  80             INSIDE = 2,
  81             OUTSIDE = 3
  82         };
  83
  84 private:
  85
  86     // Private data
  87
  88         const word name_;
  89
  90
  91     // Private Member Functions
  92
  93         //- Disallow default bitwise copy construct
  94         searchableSurface(const searchableSurface&);
  95
  96         //- Disallow default bitwise assignment
  97         void operator=(const searchableSurface&);
  98
  99
 100 public:
 101
 102     //- Runtime type information
 103     TypeName("searchableSurface");
 104
 105     // Declare run-time constructor selection table
 106
 107         // For the dictionary constructor
 108         declareRunTimeSelectionTable
 109         (
 110             autoPtr,
 111             searchableSurface,
 112             dict,
 113             (
 114                 const IOobject& io,
 115                 const dictionary& dict
 116             ),
 117             (io, dict)
 118         );
 119
 120
 121         //- Class used for the read-construction of
 122         //  PtrLists of searchableSurface.
 123         class iNew
 124         {
 125             IOobject& io_;
 126
 127         public:
 128
 129             iNew(IOobject& io)
 130             :
 131                 io_(io)
 132             {}
 133
 134             autoPtr<searchableSurface> operator()(Istream& is) const
 135             {
 136                 word surfaceType(is);
 137                 word readName(is);
 138                 dictionary dict(is);
 139
 140                 autoPtr<IOobject> namedIO(io_.clone());
 141                 namedIO().rename(readName);
 142                 return searchableSurface::New(surfaceType, namedIO(), dict);
 143             }
 144         };
 145
 146
 147     // Constructors
 148
 149         searchableSurface(const IOobject& io);
 150
 151         //- Clone
 152         virtual autoPtr<searchableSurface> clone() const
 153         {
 154             notImplemented("autoPtr<searchableSurface> clone() const");
 155             return autoPtr<searchableSurface>(NULL);
 156         }
 157
 158
 159     // Selectors
 160
 161         //- Return a reference to the selected searchableSurface
 162         static autoPtr<searchableSurface> New
 163         (
 164             const word& surfaceType,
 165             const IOobject& io,
 166             const dictionary& dict
 167         );
 168
 169
 170     // Destructor
 171
 172         virtual ~searchableSurface();
 173
 174
 175     // Member Functions
 176
 177
 178         //- Names of regions.
 179         virtual const wordList& regions() const = 0;
 180
 181         //- Whether supports volume type below.
 182         virtual bool hasVolumeType() const = 0;
 183
 184         //- Range of local indices that can be returned.
 185         virtual label size() const = 0;
 186
 187         //- Range of global indices that can be returned.
 188         virtual label globalSize() const
 189         {
 190             return size();
 191         }
 192
 193         //- Get representative set of element coordinates
 194         //  Usually the element centres (should be of length size()).
 195         virtual pointField coordinates() const = 0;
 196
 197
 198         // Single point queries.
 199
 200             ////- Calculate nearest point on surface. Returns
 201             ////  - bool : any point found nearer than nearestDistSqr
 202             ////  - label: relevant index in surface
 203             ////  - label: region in surface
 204             ////  - point: actual nearest point found
 205             //virtual pointIndexHit findNearest
 206             //(
 207             //    const point& sample,
 208             //    const scalar nearestDistSqr
 209             //) const = 0;
 210             //
 211             ////- Calculate nearest point on edge. Returns
 212             ////  - bool : any point found nearer than nearestDistSqr
 213             ////  - label: relevant index in surface
 214             ////  - label: region in surface
 215             ////  - point: actual nearest point found
 216             //virtual pointIndexHit findNearestOnEdge
 217             //(
 218             //    const point& sample,
 219             //    const scalar nearestDistSqr
 220             //) const = 0;
 221             //
 222             ////- Find nearest to segment. Returns
 223             ////  - bool : any point found?
 224             ////  - label: relevant index in shapes
 225             ////  - label: region in surface
 226             ////  - point: actual nearest point found
 227             ////  sets:
 228             ////  - tightest  : bounding box
 229             ////  - linePoint : corresponding nearest point on line
 230             //virtual pointIndexHit findNearest
 231             //(
 232             //    const linePointRef& ln,
 233             //    treeBoundBox& tightest,
 234             //    point& linePoint
 235             //) const = 0;
 236             //
 237             ////- Find nearest intersection of line between start and end.
 238             //virtual pointIndexHit findLine
 239             //(
 240             //    const point& start,
 241             //    const point& end
 242             //) const = 0;
 243             //
 244             ////- Find any intersection of line between start and end.
 245             //virtual pointIndexHit findLineAny
 246             //(
 247             //    const point& start,
 248             //    const point& end
 249             //) const = 0;
 250
 251
 252         // Multiple point queries. When surface is distributed the index
 253         // should be a global index. Not done yet.
 254
 255             virtual void findNearest
 256             (
 257                 const pointField& sample,
 258                 const scalarField& nearestDistSqr,
 259                 List<pointIndexHit>&
 260             ) const = 0;
 261
 262             //- Find first intersection on segment from start to end.
 263             //  Note: searchableSurfacesQueries expects no
 264             //  intersection to be found if start==end. Is problem?
 265             virtual void findLine
 266             (
 267                 const pointField& start,
 268                 const pointField& end,
 269                 List<pointIndexHit>&
 270             ) const = 0;
 271
 272             //- Return any intersection on segment from start to end.
 273             virtual void findLineAny
 274             (
 275                 const pointField& start,
 276                 const pointField& end,
 277                 List<pointIndexHit>&
 278             ) const = 0;
 279
 280             //- Get all intersections in order from start to end.
 281             virtual void findLineAll
 282             (
 283                 const pointField& start,
 284                 const pointField& end,
 285                 List<List<pointIndexHit> >&
 286             ) const = 0;
 287
 288             //- From a set of points and indices get the region
 289             virtual void getRegion
 290             (
 291                 const List<pointIndexHit>&,
 292                 labelList& region
 293             ) const = 0;
 294
 295             //- From a set of points and indices get the normal
 296             virtual void getNormal
 297             (
 298                 const List<pointIndexHit>&,
 299                 vectorField& normal
 300             ) const = 0;
 301
 302             //- Determine type (inside/outside) for point. unknown if
 303             //  cannot be determined (e.g. non-manifold surface)
 304             virtual void getVolumeType
 305             (
 306                 const pointField&,
 307                 List<volumeType>&
 308             ) const = 0;
 309
 310
 311         // Other
 312
 313             //- Set bounds of surface. Bounds currently set as list of
 314             //  bounding boxes. The bounds are hints to the surface as for
 315             //  the range of queries it can expect. faceMap/pointMap can be
 316             //  set if the surface has done any redistribution.
 317             virtual void distribute
 318             (
 319                 const List<treeBoundBox>&,
 320                 const bool keepNonLocal,
 321                 autoPtr<mapDistribute>& faceMap,
 322                 autoPtr<mapDistribute>& pointMap
 323             )
 324             {}
 325
 326             //- WIP. Store element-wise field.
 327             virtual void setField(const labelList& values)
 328             {}
 329
 330             //- WIP. From a set of hits (points and
 331             //  indices) get the specified field. Misses do not get set. Return
 332             //  empty field if not supported.
 333             virtual void getField(const List<pointIndexHit>&, labelList& values)
 334             const
 335             {
 336                 values.clear();
 337             }
 338
 339 };
 340
 341
 342 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 343
 344 } // End namespace Foam
 345
 346 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 347
 348 #endif
 349
 350 // ************************************************************************* //