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