src/OpenFOAM/algorithms/MeshWave/FaceCellWave.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::FaceCellWave
  26
  27 Description
  28     Wave propagation of information through grid. Every iteration
  29     information goes through one layer of cells. Templated on information
  30     that is transferred.
  31
  32     Handles parallel and cyclics and non-parallel cyclics.
  33
  34     Note: whether to propagate depends on the return value of Type::update
  35     which returns true (i.e. propagate) if the value changes by more than a
  36     certain tolerance.
  37     This tolerance can be very strict for normal face-cell and parallel
  38     cyclics (we use a value of 0.01 just to limit propagation of small changes)
  39     but for non-parallel cyclics this tolerance can be critical and if chosen
  40     too small can lead to non-convergence.
  41
  42 SourceFiles
  43     FaceCellWave.C
  44
  45 \*---------------------------------------------------------------------------*/
  46
  47 #ifndef FaceCellWave_H
  48 #define FaceCellWave_H
  49
  50 #include "boolList.H"
  51 #include "labelList.H"
  52 #include "primitiveFieldsFwd.H"
  53
  54 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
  55
  56 namespace Foam
  57 {
  58
  59 // Forward declaration of classes
  60 class polyMesh;
  61 class polyPatch;
  62
  63 /*---------------------------------------------------------------------------*\
  64                         Class FaceCellWaveName Declaration
  65 \*---------------------------------------------------------------------------*/
  66
  67 TemplateName(FaceCellWave);
  68
  69
  70 /*---------------------------------------------------------------------------*\
  71                            Class FaceCellWave Declaration
  72 \*---------------------------------------------------------------------------*/
  73
  74 template<class Type, class TrackingData = int>
  75 class FaceCellWave
  76 :
  77     public FaceCellWaveName
  78 {
  79     // Private data
  80
  81         //- Reference to mesh
  82         const polyMesh& mesh_;
  83
  84         //- Information for all faces
  85         UList<Type>& allFaceInfo_;
  86
  87         //- Information for all cells
  88         UList<Type>& allCellInfo_;
  89
  90         //- Additional data to be passed into container
  91         TrackingData& td_;
  92
  93         //- Has face changed
  94         boolList changedFace_;
  95
  96         //- List of changed faces
  97         labelList changedFaces_;
  98
  99         //- Number of changed faces
 100         label nChangedFaces_;
 101
 102         // Cells that have changed
 103         boolList changedCell_;
 104         labelList changedCells_;
 105         label nChangedCells_;
 106
 107         //- Contains cyclics
 108         bool hasCyclicPatches_;
 109
 110         //- Number of evaluations
 111         label nEvals_;
 112
 113         //- Number of unvisited cells/faces
 114         label nUnvisitedCells_;
 115         label nUnvisitedFaces_;
 116
 117
 118     // Private Member Functions
 119
 120         //- Disallow default bitwise copy construct
 121         FaceCellWave(const FaceCellWave&);
 122
 123         //- Disallow default bitwise assignment
 124         void operator=(const FaceCellWave&);
 125
 126
 127         //- Updates cellInfo with information from neighbour. Updates all
 128         //  statistics.
 129         bool updateCell
 130         (
 131             const label cellI,
 132             const label neighbourFaceI,
 133             const Type& neighbourInfo,
 134             const scalar tol,
 135             Type& cellInfo
 136         );
 137
 138         //- Updates faceInfo with information from neighbour. Updates all
 139         //  statistics.
 140         bool updateFace
 141         (
 142             const label faceI,
 143             const label neighbourCellI,
 144             const Type& neighbourInfo,
 145             const scalar tol,
 146             Type& faceInfo
 147         );
 148
 149         //- Updates faceInfo with information from same face. Updates all
 150         //  statistics.
 151         bool updateFace
 152         (
 153             const label faceI,
 154             const Type& neighbourInfo,
 155             const scalar tol,
 156             Type& faceInfo
 157         );
 158
 159
 160         // Parallel, cyclic
 161
 162             //- Debugging: check info on both sides of cyclic
 163             void checkCyclic(const polyPatch& pPatch) const;
 164
 165             //- Has cyclic patch?
 166             bool hasCyclicPatch() const;
 167
 168             //- Merge received patch data into global data
 169             void mergeFaceInfo
 170             (
 171                 const polyPatch& patch,
 172                 const label nFaces,
 173                 const labelList&,
 174                 const List<Type>&
 175             );
 176
 177             //- Extract info for single patch only
 178             label getChangedPatchFaces
 179             (
 180                 const polyPatch& patch,
 181                 const label startFaceI,
 182                 const label nFaces,
 183                 labelList& changedPatchFaces,
 184                 List<Type>& changedPatchFacesInfo
 185             ) const;
 186
 187             //- Handle leaving domain. Implementation referred to Type
 188             void leaveDomain
 189             (
 190                 const polyPatch& patch,
 191                 const label nFaces,
 192                 const labelList& faceLabels,
 193                 List<Type>& faceInfo
 194             ) const;
 195
 196             //- Handle leaving domain. Implementation referred to Type
 197             void enterDomain
 198             (
 199                 const polyPatch& patch,
 200                 const label nFaces,
 201                 const labelList& faceLabels,
 202                 List<Type>& faceInfo
 203             ) const;
 204
 205             //- Offset face labels by constant value
 206             static void offset
 207             (
 208                 const polyPatch& patch,
 209                 const label off,
 210                 const label nFaces,
 211                 labelList& faces
 212             );
 213
 214             //- Apply transformation to Type
 215             void transform
 216             (
 217                 const tensorField& rotTensor,
 218                 const label nFaces,
 219                 List<Type>& faceInfo
 220             );
 221
 222             //- Merge data from across processor boundaries
 223             void handleProcPatches();
 224
 225             //- Merge data from across cyclics
 226             void handleCyclicPatches();
 227
 228
 229       // Private static data
 230
 231             static const scalar geomTol_;
 232             static scalar propagationTol_;
 233
 234             //- Used as default trackdata value to satisfy default template
 235             //  argument.
 236             static label dummyTrackData_;
 237
 238
 239 public:
 240
 241     // Static Functions
 242
 243         //- Access to tolerance
 244         static scalar propagationTol()
 245         {
 246             return propagationTol_;
 247         }
 248
 249         //- Change tolerance
 250         static void setPropagationTol(const scalar tol)
 251         {
 252             propagationTol_ = tol;
 253         }
 254
 255
 256     // Constructors
 257
 258         // Construct from mesh. Use setFaceInfo and iterate() to do actual
 259         // calculation.
 260         FaceCellWave
 261         (
 262             const polyMesh&,
 263             UList<Type>& allFaceInfo,
 264             UList<Type>& allCellInfo,
 265             TrackingData& td = dummyTrackData_
 266         );
 267
 268         //- Construct from mesh and list of changed faces with the Type
 269         //  for these faces. Iterates until nothing changes or maxIter reached.
 270         //  (maxIter can be 0)
 271         FaceCellWave
 272         (
 273             const polyMesh&,
 274             const labelList& initialChangedFaces,
 275             const List<Type>& changedFacesInfo,
 276             UList<Type>& allFaceInfo,
 277             UList<Type>& allCellInfo,
 278             const label maxIter,
 279             TrackingData& td = dummyTrackData_
 280         );
 281
 282
 283     // Member Functions
 284
 285         // Access
 286
 287             //- Access allFaceInfo
 288             UList<Type>& allFaceInfo()
 289             {
 290                 return allFaceInfo_;
 291             }
 292
 293             //- Access allCellInfo
 294             UList<Type>& allCellInfo()
 295             {
 296                 return allCellInfo_;
 297             }
 298
 299             //- Additional data to be passed into container
 300             const TrackingData& data() const
 301             {
 302                 return td_;
 303             }
 304
 305             //- Access mesh
 306             const polyMesh& mesh() const
 307             {
 308                 return mesh_;
 309             }
 310
 311             //- Get number of unvisited cells, i.e. cells that were not (yet)
 312             //  reached from walking across mesh. This can happen from
 313             //  - not enough iterations done
 314             //  - a disconnected mesh
 315             //  - a mesh without walls in it
 316             label getUnsetCells() const;
 317
 318             //- Get number of unvisited faces
 319             label getUnsetFaces() const;
 320
 321
 322         // Edit
 323
 324             //- Set initial changed faces
 325             void setFaceInfo
 326             (
 327                 const labelList& changedFaces,
 328                 const List<Type>& changedFacesInfo
 329             );
 330
 331             //- Propagate from face to cell. Returns total number of cells
 332             //  (over all processors) changed.
 333             label faceToCell();
 334
 335             //- Propagate from cell to face. Returns total number of faces
 336             //  (over all processors) changed. (Faces on processorpatches are
 337             //  counted double)
 338             label cellToFace();
 339
 340             //- Iterate until no changes or maxIter reached.  Returns actual
 341             //  number of iterations.
 342             label iterate(const label maxIter);
 343
 344 };
 345
 346
 347 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 348
 349 } // End namespace Foam
 350
 351
 352 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 353
 354 #ifdef NoRepository
 355 #   include "FaceCellWave.C"
 356 #endif
 357
 358 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 359
 360 #endif
 361
 362 // ************************************************************************* //