src/autoMesh/autoHexMesh/autoHexMeshDriver/autoHexMeshDriver.H

   1 /*---------------------------------------------------------------------------*\
   2   =========                 |
   3   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
   4    \\    /   O peration     |
   5     \\  /    A nd           | Copyright (C) 1991-2008 OpenCFD Ltd.
   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::autoHexMeshDriver
  27
  28 Description
  29     main meshing driver.
  30
  31 SourceFiles
  32     autoHexMeshDriver.C
  33
  34 \*---------------------------------------------------------------------------*/
  35
  36 #ifndef autoHexMeshDriver_H
  37 #define autoHexMeshDriver_H
  38
  39 #include "autoPtr.H"
  40 #include "dictionary.H"
  41 #include "pointField.H"
  42 #include "boolList.H"
  43 #include "wallPoint.H"
  44 #include "searchableSurfaces.H"
  45 #include "refinementSurfaces.H"
  46 #include "shellSurfaces.H"
  47 #include "meshRefinement.H"
  48 #include "decompositionMethod.H"
  49 #include "fvMeshDistribute.H"
  50
  51 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
  52
  53 namespace Foam
  54 {
  55
  56 // Class forward declarations
  57 class fvMesh;
  58
  59 /*---------------------------------------------------------------------------*\
  60                            Class autoHexMeshDriver Declaration
  61 \*---------------------------------------------------------------------------*/
  62
  63 class autoHexMeshDriver
  64 {
  65     // Static data members
  66
  67         //- Extrusion controls
  68         enum extrudeMode
  69         {
  70             NOEXTRUDE,      /*!< Do not extrude. No layers added. */
  71             EXTRUDE,        /*!< Extrude */
  72             EXTRUDEREMOVE   /*!< Extrude but afterwards remove added */
  73                             /*!< faces locally */
  74         };
  75
  76
  77     // Private classes
  78
  79         //- Combine operator class for equalizing displacements.
  80         class minMagEqOp
  81         {
  82         public:
  83
  84             void operator()(vector& x, const vector& y) const
  85             {
  86                 if (magSqr(y) < magSqr(x))
  87                 {
  88                     x = y;
  89                 }
  90             }
  91         };
  92
  93         //- Combine operator class to combine normal with other normal.
  94         class nomalsCombine
  95         {
  96         public:
  97
  98             void operator()(vector& x, const vector& y) const
  99             {
 100                 if (y != wallPoint::greatPoint)
 101                 {
 102                     if (x == wallPoint::greatPoint)
 103                     {
 104                         x = y;
 105                     }
 106                     else
 107                     {
 108                         x *= (x&y);
 109                     }
 110                 }
 111             }
 112         };
 113
 114
 115
 116     // Private data
 117
 118         //- Reference to mesh
 119         fvMesh& mesh_;
 120
 121         //- Input dictionary
 122         const dictionary dict_;
 123
 124         //- Debug level
 125         const label debug_;
 126
 127         //- Merge distance
 128         const scalar mergeDist_;
 129
 130
 131         //- All surface based geometry
 132         autoPtr<searchableSurfaces> allGeometryPtr_;
 133
 134         //- Shells (geometry for inside/outside refinement)
 135         autoPtr<shellSurfaces> shellsPtr_;
 136
 137         //- Surfaces (geometry for intersection based refinement)
 138         autoPtr<refinementSurfaces> surfacesPtr_;
 139
 140         //- Per refinement surface region the patch
 141         labelList globalToPatch_;
 142
 143         //- Mesh refinement engine
 144         autoPtr<meshRefinement> meshRefinerPtr_;
 145
 146         //- Decomposition engine
 147         autoPtr<decompositionMethod> decomposerPtr_;
 148
 149         //- Mesh distribution engine
 150         autoPtr<fvMeshDistribute> distributorPtr_;
 151
 152
 153
 154     // Private Member Functions
 155
 156         //- Calculate merge distance. Check against writing tolerance.
 157         scalar getMergeDistance(const scalar mergeTol) const;
 158
 159         //static void orientOutside(PtrList<searchableSurface>&);
 160
 161         //- Disallow default bitwise copy construct
 162         autoHexMeshDriver(const autoHexMeshDriver&);
 163
 164         //- Disallow default bitwise assignment
 165         void operator=(const autoHexMeshDriver&);
 166
 167 public:
 168
 169     //- Runtime type information
 170     ClassName("autoHexMeshDriver");
 171
 172
 173     // Constructors
 174
 175         //- Construct from dictionary and mesh to modify
 176         autoHexMeshDriver
 177         (
 178             fvMesh& mesh,
 179             const dictionary& meshDict,
 180             const dictionary& decomposeDict
 181         );
 182
 183
 184     // Member Functions
 185
 186         // Access
 187
 188             //- reference to mesh
 189             const fvMesh& mesh() const
 190             {
 191                 return mesh_;
 192             }
 193             fvMesh& mesh()
 194             {
 195                 return mesh_;
 196             }
 197
 198             //- Surfaces to base refinement on
 199             const refinementSurfaces& surfaces() const
 200             {
 201                 return surfacesPtr_();
 202             }
 203
 204             //- Surfaces to volume refinement on
 205             const shellSurfaces& shells() const
 206             {
 207                 return shellsPtr_();
 208             }
 209
 210             //- Per refinementsurface, per region the patch
 211             const labelList& globalToPatch() const
 212             {
 213                 return globalToPatch_;
 214             }
 215
 216
 217         // Meshing
 218
 219             //- Write mesh
 220             void writeMesh(const string&) const;
 221
 222             //- Do all : refine, snap, layers
 223             void doMesh();
 224 };
 225
 226
 227 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 228
 229 } // End namespace Foam
 230
 231 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 232
 233 #endif
 234
 235 // ************************************************************************* //