src/dynamicMesh/dynamicTopoFvMesh/lengthScaleEstimator/lengthScaleEstimator.H

   1 /*---------------------------------------------------------------------------*\
   2   =========                 |
   3   \\      /  F ield         | foam-extend: Open Source CFD
   4    \\    /   O peration     | Version:     3.2
   5     \\  /    A nd           | Web:         http://www.foam-extend.org
   6      \\/     M anipulation  | For copyright notice see file Copyright
   7 -------------------------------------------------------------------------------
   8 License
   9     This file is part of foam-extend.
  10
  11     foam-extend 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 3 of the License, or (at your
  14     option) any later version.
  15
  16     foam-extend is distributed in the hope that it will be useful, but
  17     WITHOUT ANY WARRANTY; without even the implied warranty of
  18     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  19     General Public License for more details.
  20
  21     You should have received a copy of the GNU General Public License
  22     along with foam-extend.  If not, see <http://www.gnu.org/licenses/>.
  23
  24 Class
  25     lengthScaleEstimator
  26
  27 Description
  28     Utility class used to provide length-scale estimates at various
  29     mesh locations. These estimates are based on specified boundary
  30     conditions provided through dictionary entries.
  31
  32 Author
  33     Sandeep Menon
  34     University of Massachusetts Amherst
  35     All rights reserved
  36
  37 SourceFiles
  38     lengthScaleEstimator.C
  39     lengthScaleEstimatorI.H
  40
  41 \*---------------------------------------------------------------------------*/
  42
  43 #ifndef lengthScaleEstimator_H
  44 #define lengthScaleEstimator_H
  45
  46 #include "Tuple2.H"
  47 #include "polyMesh.H"
  48 #include "dictionary.H"
  49
  50 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
  51
  52 namespace Foam
  53 {
  54
  55 /*---------------------------------------------------------------------------*\
  56                       Class lengthScaleEstimator Declaration
  57 \*---------------------------------------------------------------------------*/
  58
  59 class lengthScaleEstimator
  60 {
  61     // Private data
  62
  63         //- Const reference to polyMesh
  64         const polyMesh& mesh_;
  65
  66         //- Edge bisection/collapse criteria
  67         scalar ratioMin_;
  68         scalar ratioMax_;
  69         scalar growthFactor_;
  70         scalar minLengthScale_;
  71         scalar maxLengthScale_;
  72         scalar curvatureDeviation_;
  73
  74         //- Specific to proximity-based refinement
  75         label spatialRes_;
  76         boundBox proxBoundBox_;
  77         labelListList proximityBins_;
  78
  79         //- Specific to mesh-slicing operations
  80         scalar sliceThreshold_;
  81         label sliceHoldOff_;
  82         List<boundBox> sliceBoxes_;
  83
  84         // Buffers for parallel length-scale calculations
  85         labelListList sendLblBuffer_;
  86         labelListList recvLblBuffer_;
  87         labelListList sendLvlBuffer_;
  88         labelListList recvLvlBuffer_;
  89         scalarListList sendSclBuffer_;
  90         scalarListList recvSclBuffer_;
  91
  92         //- Sub-dictionary which specifies
  93         //  fixed length-scales for patches
  94         dictionary fixedPatches_;
  95
  96         //- Sub-dictionary which specifies
  97         //  floating length-scales for patches
  98         dictionary freePatches_;
  99
 100         //- Sub-dictionary which specifies
 101         //  patches with curvature-based length-scale
 102         dictionary curvaturePatches_;
 103
 104         //- Sub-dictionary which specifies
 105         //  patches with proximity-based length-scale
 106         dictionary proximityPatches_;
 107
 108         //- Patches for which edge-refinements
 109         //  are to be avoided
 110         labelList noModPatchIDs_;
 111
 112         //- Typedefs for field refinement function pointers
 113         typedef scalar (lengthScaleEstimator::*ScaleFn)(const scalar) const;
 114         typedef Tuple2<const char*, ScaleFn> ScaleFnPair;
 115
 116         //- Field-based refinement
 117         word field_;
 118         ScaleFn scale_;
 119         bool gradient_;
 120         scalar fieldLength_;
 121         scalar lowerRefineLevel_;
 122         scalar upperRefineLevel_;
 123
 124         //- Specify limits for refinement criteria
 125         scalar meanScale_;
 126         label maxRefineLevel_;
 127
 128         //- Function pointers for scale methods
 129         static ScaleFnPair methods_[];
 130
 131     // Private Member Functions
 132
 133         // Check for legitimacy of patches
 134         void checkPatches(const wordList& patchList) const;
 135
 136         // Prepare for proximity-based refinement, if necessary
 137         void prepareProximityPatches();
 138
 139         // Perform spatial hashing on a set of points
 140         static void spatialHash
 141         (
 142             const pointField& pointLocations,
 143             const labelList& pointIndices,
 144             const boundBox& box,
 145             const label resolution,
 146             labelListList& bins
 147         );
 148
 149         // Send length-scale info across processors
 150         void writeLengthScaleInfo
 151         (
 152             const labelList& cellLevels,
 153             const scalarList& lengthScale
 154         );
 155
 156         // Receive length-scale info across processors
 157         void readLengthScaleInfo
 158         (
 159             const label level,
 160             label& visitedCells,
 161             labelList& cellLevels,
 162             UList<scalar>& lengthScale,
 163             labelHashSet& levelCells
 164         ) const;
 165
 166         // Use a constant length scale for field-based refinement
 167         scalar constantScale(const scalar fieldValue) const;
 168
 169         // Use a direct-proportion length scale for field-based refinement
 170         scalar directScale(const scalar fieldValue) const;
 171
 172         // Use an inverse-proportion length scale for field-based refinement
 173         scalar inverseScale(const scalar fieldValue) const;
 174
 175 public:
 176
 177     // Declare the name of the class and its debug switch
 178
 179         TypeName("lengthScaleEstimator");
 180
 181     // Constructors
 182
 183         //- Construct from polyMesh and dictionary
 184         explicit lengthScaleEstimator
 185         (
 186             const polyMesh& mesh
 187         );
 188
 189     // Destructor
 190
 191         virtual ~lengthScaleEstimator();
 192
 193     // Member Functions
 194
 195         //- Read edge refinement options from the dictionary
 196         void readRefinementOptions
 197         (
 198             const dictionary& refineDict,
 199             bool reRead = false,
 200             bool mandatory = false
 201         );
 202
 203         //- Set explicitly coupled patch information
 204         void setCoupledPatches
 205         (
 206             const dictionary& coupledPatches
 207         );
 208
 209         //- Calculate the length scale field
 210         void calculateLengthScale(UList<scalar>& lengthScale);
 211
 212         //- Return refinement criteria
 213         inline scalar ratioMin() const;
 214         inline scalar ratioMax() const;
 215         inline scalar growthFactor() const;
 216
 217         //- Limit length scale for surface-edges
 218         inline void limitScale(scalar& scale) const;
 219
 220         //- Check if a particular patch is free-floating
 221         //  (i.e., gets its length-scale from the interior)
 222         inline bool isFreePatch(const label pIndex) const;
 223
 224         //- Check if a particular patch is flagged
 225         //  for proximity-based refinement
 226         inline bool isProximityPatch(const label pIndex) const;
 227
 228         //- Check if a particular patch is flagged
 229         //  for curvature-based refinement
 230         inline bool isCurvaturePatch(const label pIndex) const;
 231
 232         //- Return reference curvature deviation
 233         inline scalar curvatureDeviation() const
 234         {
 235             return curvatureDeviation_;
 236         }
 237
 238         //- Check whether a particular point is too close
 239         //  to a previous mesh slice location
 240         inline bool checkOldSlices(const vector& gCentre) const;
 241
 242         //- Add a boundBox to the existing set of sliceBoxes
 243         inline void appendBox(const boundBox& bBox);
 244
 245         //- Clear the list of sliceBoxes
 246         inline void clearBoxes();
 247
 248         //- Set an initial hold-off value
 249         inline void setHoldOff(const label hVal)
 250         {
 251             sliceHoldOff_ = hVal;
 252         }
 253
 254         //- Return the current holdOff value
 255         inline label holdOff() const
 256         {
 257             return sliceHoldOff_;
 258         }
 259
 260         //- Decrement the current holdOff value
 261         inline void decrementHoldOff()
 262         {
 263             sliceHoldOff_--;
 264         }
 265
 266         //- Check whether a particular patch permits refinement
 267         inline bool checkRefinementPatch
 268         (
 269             const label pIndex
 270         ) const;
 271
 272         //- Return the appropriate length-scale for boundary face
 273         inline scalar fixedLengthScale
 274         (
 275             const label fIndex,
 276             const label pIndex,
 277             bool usePolyMesh = false
 278         ) const;
 279
 280         //- Test for proximity to patch faces
 281         inline bool testProximity
 282         (
 283             const vector& gCentre,
 284             const vector& gNormal,
 285             const scalar testStep,
 286             label& proxFace,
 287             scalar& proxDistance
 288         ) const;
 289 };
 290
 291 } // End namespace Foam
 292
 293 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 294
 295 #include "lengthScaleEstimatorI.H"
 296
 297 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 298
 299 #endif