src/mesh/autoMesh/autoHexMesh/refinementSurfaces/refinementSurfaces.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::refinementSurfaces
  26
  27 Description
  28     Container for data on surfaces used for surface-driven refinement.
  29     Contains all the data about the level of refinement needed per
  30     surface.
  31
  32 SourceFiles
  33     refinementSurfaces.C
  34
  35 \*---------------------------------------------------------------------------*/
  36
  37 #ifndef refinementSurfaces_H
  38 #define refinementSurfaces_H
  39
  40 #include "triSurfaceGeoMesh.H"
  41 #include "triSurfaceFields.H"
  42 #include "vectorList.H"
  43 #include "pointIndexHit.H"
  44
  45 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
  46
  47 namespace Foam
  48 {
  49
  50 class searchableSurfaces;
  51 class shellSurfaces;
  52 class triSurfaceMesh;
  53
  54 /*---------------------------------------------------------------------------*\
  55                            Class refinementSurfaces Declaration
  56 \*---------------------------------------------------------------------------*/
  57
  58 class refinementSurfaces
  59 {
  60 public:
  61
  62     //- Types of selection of area
  63     enum areaSelectionAlgo
  64     {
  65         INSIDE,
  66         OUTSIDE,
  67         INSIDEPOINT,
  68         NONE
  69     };
  70
  71     static const NamedEnum<areaSelectionAlgo, 4> areaSelectionAlgoNames;
  72
  73 private:
  74
  75     // Private data
  76
  77         //- Reference to all geometry.
  78         const searchableSurfaces& allGeometry_;
  79
  80         //- Indices of surfaces that are refinement ones
  81         labelList surfaces_;
  82
  83         //- Surface name (word)
  84         wordList names_;
  85
  86         //- Per 'interface' surface : name of faceZone to put faces into
  87         wordList faceZoneNames_;
  88
  89         //- Per 'interface' surface : name of cellZone to put cells into
  90         wordList cellZoneNames_;
  91
  92         //- Per 'interface' surface : (only used if surface is closed)
  93         //  How to select zone cells : surface inside or outside or given
  94         //  inside location.
  95         List<areaSelectionAlgo> zoneInside_;
  96
  97         //- If zoneInside=location gives the corresponding inside point
  98         pointField zoneInsidePoints_;
  99
 100         //- From local region number to global region number
 101         labelList regionOffset_;
 102
 103         //- From global region number to refinement level
 104         labelList minLevel_;
 105
 106         //- From global region number to refinement level
 107         labelList maxLevel_;
 108
 109         //- From global region number to perpendicular angle
 110         scalarField perpendicularAngle_;
 111
 112         //- From global region number to patchType
 113         PtrList<dictionary> patchInfo_;
 114
 115
 116     // Private Member Functions
 117
 118         //- Disallow default bitwise copy construct
 119         refinementSurfaces(const refinementSurfaces&);
 120
 121         //- Disallow default bitwise assignment
 122         void operator=(const refinementSurfaces&);
 123
 124
 125 public:
 126
 127     // Constructors
 128
 129         //- Construct from surfaces and dictionary
 130         refinementSurfaces
 131         (
 132             const searchableSurfaces& allGeometry,
 133             const dictionary&
 134         );
 135
 136
 137     // Member Functions
 138
 139         // Access
 140
 141             const searchableSurfaces& geometry() const
 142             {
 143                 return allGeometry_;
 144             }
 145
 146             const labelList& surfaces() const
 147             {
 148                 return surfaces_;
 149             }
 150
 151             //- Names of surfaces
 152             const wordList& names() const
 153             {
 154                 return names_;
 155             }
 156
 157             //- Per 'interface' surface : name of faceZone to put faces into
 158             const wordList& faceZoneNames() const
 159             {
 160                 return faceZoneNames_;
 161             }
 162
 163             //- Per 'interface' surface : empty or name of cellZone to put
 164             //  cells into
 165             const wordList& cellZoneNames() const
 166             {
 167                 return cellZoneNames_;
 168             }
 169
 170             //- Get indices of unnamed surfaces (surfaces without faceZoneName)
 171             labelList getUnnamedSurfaces() const;
 172
 173             //- Get indices of named surfaces (surfaces with faceZoneName)
 174             labelList getNamedSurfaces() const;
 175
 176             //- Get indices of surfaces with a cellZone that are closed and
 177             //  have 'inside' or 'outside' selection.
 178             labelList getClosedNamedSurfaces() const;
 179
 180             //- Get indices of surfaces with a cellZone that have 'insidePoint'
 181             //  section.
 182             labelList getInsidePointNamedSurfaces() const;
 183
 184             //- Get specified inside locations for surfaces with a cellZone
 185             const pointField& zoneInsidePoints() const
 186             {
 187                 return zoneInsidePoints_;
 188             }
 189
 190             //- From local region number to global region number
 191             const labelList& regionOffset() const
 192             {
 193                 return regionOffset_;
 194             }
 195
 196             //- From global region number to refinement level
 197             const labelList& minLevel() const
 198             {
 199                 return minLevel_;
 200             }
 201
 202             //- From global region number to refinement level
 203             const labelList& maxLevel() const
 204             {
 205                 return maxLevel_;
 206             }
 207
 208             //- From global region number to perpendicular angle
 209             const scalarField& perpendicularAngle() const
 210             {
 211                 return perpendicularAngle_;
 212             }
 213
 214             //- From global region number to patch type
 215             const PtrList<dictionary>& patchInfo() const
 216             {
 217                 return patchInfo_;
 218             }
 219
 220
 221         // Helper
 222
 223             //- From surface and region on surface to global region
 224             label globalRegion(const label surfI, const label regionI) const
 225             {
 226                 return regionOffset_[surfI]+regionI;
 227             }
 228
 229             //- Min level for surface and region on surface
 230             label minLevel(const label surfI, const label regionI) const
 231             {
 232                 return minLevel_[globalRegion(surfI, regionI)];
 233             }
 234
 235             //- Max level for surface and region on surface
 236             label maxLevel(const label surfI, const label regionI) const
 237             {
 238                 return maxLevel_[globalRegion(surfI, regionI)];
 239             }
 240
 241             label nRegions() const
 242             {
 243                 return minLevel_.size();
 244             }
 245
 246             //- Calculate minLevelFields
 247             void setMinLevelFields
 248             (
 249                 const shellSurfaces& shells
 250             );
 251
 252             ////- Helper: count number of triangles per region
 253             //static labelList countRegions(const triSurface&);
 254
 255
 256         // Searching
 257
 258             //- Find intersection of edge. Return -1 or first surface
 259             //  with higher (than currentLevel) minlevel.
 260             //  Return surface number and level.
 261             void findHigherIntersection
 262             (
 263                 const pointField& start,
 264                 const pointField& end,
 265                 const labelList& currentLevel,  // current cell refinement level
 266
 267                 labelList& surfaces,
 268                 labelList& surfaceLevel
 269             ) const;
 270
 271             //- Find all intersections of edge. Unsorted order.
 272             void findAllHigherIntersections
 273             (
 274                 const pointField& start,
 275                 const pointField& end,
 276                 const labelList& currentLevel,  // current cell refinement level
 277
 278                 List<vectorList>& surfaceNormal,
 279                 labelListList& surfaceLevel
 280             ) const;
 281
 282             //- Find intersection nearest to the endpoints. surface1,2 are
 283             //  not indices into surfacesToTest but refinement surface indices.
 284             //  Returns surface, region on surface (so not global surface)
 285             //  and position on surface.
 286             void findNearestIntersection
 287             (
 288                 const labelList& surfacesToTest,
 289                 const pointField& start,
 290                 const pointField& end,
 291
 292                 labelList& surface1,
 293                 List<pointIndexHit>& hit1,
 294                 labelList& region1,
 295                 labelList& surface2,
 296                 List<pointIndexHit>& hit2,
 297                 labelList& region2
 298             ) const;
 299
 300             //- Used for debugging only: find intersection of edge.
 301             void findAnyIntersection
 302             (
 303                 const pointField& start,
 304                 const pointField& end,
 305                 labelList& surfaces,
 306                 List<pointIndexHit>&
 307             ) const;
 308
 309             //- Find nearest point on surfaces.
 310             void findNearest
 311             (
 312                 const labelList& surfacesToTest,
 313                 const pointField& samples,
 314                 const scalarField& nearestDistSqr,
 315                 labelList& surfaces,
 316                 List<pointIndexHit>&
 317             ) const;
 318
 319             //- Find nearest point on surfaces. Return surface and region on
 320             //  surface (so not global surface)
 321             void findNearestRegion
 322             (
 323                 const labelList& surfacesToTest,
 324                 const pointField& samples,
 325                 const scalarField& nearestDistSqr,
 326                 labelList& hitSurface,
 327                 labelList& hitRegion
 328             ) const;
 329
 330             //- Find nearest point on surfaces. Return surface, region and
 331             //  normal on surface (so not global surface)
 332             void findNearestRegion
 333             (
 334                 const labelList& surfacesToTest,
 335                 const pointField& samples,
 336                 const scalarField& nearestDistSqr,
 337                 labelList& hitSurface,
 338                 List<pointIndexHit>& hitInfo,
 339                 labelList& hitRegion,
 340                 vectorField& hitNormal
 341             ) const;
 342
 343             //- Detect if a point is 'inside' (closed) surfaces.
 344             //  Returns -1 if not, returns first surface it is.
 345             void findInside
 346             (
 347                 const labelList& surfacesToTest,
 348                 const pointField& pt,
 349                 labelList& insideSurfaces
 350             ) const;
 351 };
 352
 353
 354 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 355
 356 } // End namespace Foam
 357
 358 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 359
 360 #endif
 361
 362 // ************************************************************************* //