src/meshTools/searchableSurface/searchablePlate.H

   1 /*---------------------------------------------------------------------------*\
   2   =========                 |
   3   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
   4    \\    /   O peration     |
   5     \\  /    A nd           | Copyright (C) 2011 OpenFOAM Foundation
   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::searchablePlate
  26
  27 Description
  28     Searching on finite plate. Plate has to be aligned with coordinate
  29     axes.
  30     Plate defined as origin and span. One of the components of span has
  31     to be 0 which defines the normal direction. E.g.
  32
  33     span    = (Sx Sy 0)     // plate in x-y plane
  34     origin  = (Ox Oy Oz)
  35
  36     now plane is from (Ox Oy Oz) to (Ox+Sx Oy+Sy Oz)
  37
  38 SourceFiles
  39     searchablePlate.C
  40
  41 \*---------------------------------------------------------------------------*/
  42
  43 #ifndef searchablePlate_H
  44 #define searchablePlate_H
  45
  46 #include "searchableSurface.H"
  47 #include "treeBoundBox.H"
  48
  49 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
  50
  51 namespace Foam
  52 {
  53
  54 // Forward declaration of classes
  55
  56 /*---------------------------------------------------------------------------*\
  57                            Class searchablePlate Declaration
  58 \*---------------------------------------------------------------------------*/
  59
  60 class searchablePlate
  61 :
  62     public searchableSurface
  63 {
  64 private:
  65
  66     // Private Member Data
  67
  68         const point origin_;
  69
  70         const vector span_;
  71
  72         //- Coordinate direction which is normal
  73         const direction normalDir_;
  74
  75         mutable wordList regions_;
  76
  77
  78     // Private Member Functions
  79
  80         //- Calculate normal direction from span
  81         static direction calcNormal(const point&);
  82
  83         pointIndexHit findNearest
  84         (
  85             const point& sample,
  86             const scalar nearestDistSqr
  87         ) const;
  88
  89         pointIndexHit findLine
  90         (
  91             const point& start,
  92             const point& end
  93         ) const;
  94
  95
  96         //- Disallow default bitwise copy construct
  97         searchablePlate(const searchablePlate&);
  98
  99         //- Disallow default bitwise assignment
 100         void operator=(const searchablePlate&);
 101
 102
 103 public:
 104
 105     //- Runtime type information
 106     TypeName("searchablePlate");
 107
 108
 109     // Constructors
 110
 111         //- Construct from components
 112         searchablePlate
 113         (
 114             const IOobject& io,
 115             const point& origin,
 116             const point& span
 117         );
 118
 119         //- Construct from dictionary (used by searchableSurface)
 120         searchablePlate
 121         (
 122             const IOobject& io,
 123             const dictionary& dict
 124         );
 125
 126     //- Destructor
 127     virtual ~searchablePlate();
 128
 129
 130     // Member Functions
 131
 132         virtual const wordList& regions() const;
 133
 134         //- Whether supports volume type below
 135         virtual bool hasVolumeType() const
 136         {
 137             return false;
 138         }
 139
 140         //- Range of local indices that can be returned.
 141         virtual label size() const
 142         {
 143             return 1;
 144         }
 145
 146         //- Get representative set of element coordinates
 147         //  Usually the element centres (should be of length size()).
 148         virtual pointField coordinates() const
 149         {
 150             return pointField(1, origin_);
 151         }
 152
 153
 154         // Multiple point queries.
 155
 156             virtual void findNearest
 157             (
 158                 const pointField& sample,
 159                 const scalarField& nearestDistSqr,
 160                 List<pointIndexHit>&
 161             ) const;
 162
 163             virtual void findLine
 164             (
 165                 const pointField& start,
 166                 const pointField& end,
 167                 List<pointIndexHit>&
 168             ) const;
 169
 170             virtual void findLineAny
 171             (
 172                 const pointField& start,
 173                 const pointField& end,
 174                 List<pointIndexHit>&
 175             ) const;
 176
 177             //- Get all intersections in order from start to end.
 178             virtual void findLineAll
 179             (
 180                 const pointField& start,
 181                 const pointField& end,
 182                 List<List<pointIndexHit> >&
 183             ) const;
 184
 185             //- From a set of points and indices get the region
 186             virtual void getRegion
 187             (
 188                 const List<pointIndexHit>&,
 189                 labelList& region
 190             ) const;
 191
 192             //- From a set of points and indices get the normal
 193             virtual void getNormal
 194             (
 195                 const List<pointIndexHit>&,
 196                 vectorField& normal
 197             ) const;
 198
 199             //- Determine type (inside/outside/mixed) for point. unknown if
 200             //  cannot be determined (e.g. non-manifold surface)
 201             virtual void getVolumeType
 202             (
 203                 const pointField&,
 204                 List<volumeType>&
 205             ) const;
 206
 207
 208         // regIOobject implementation
 209
 210             bool writeData(Ostream&) const
 211             {
 212                 notImplemented("searchablePlate::writeData(Ostream&) const");
 213                 return false;
 214             }
 215
 216 };
 217
 218
 219 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 220
 221 } // End namespace Foam
 222
 223 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 224
 225 #endif
 226
 227 // ************************************************************************* //