src/foam/algorithms/MeshWave/FaceCellWave.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     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 #include "tolerancesSwitch.H"
  54
  55 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
  56
  57 namespace Foam
  58 {
  59
  60 // Forward declaration of classes
  61 class polyMesh;
  62 class polyPatch;
  63
  64 /*---------------------------------------------------------------------------*\
  65                         Class FaceCellWaveName Declaration
  66 \*---------------------------------------------------------------------------*/
  67
  68 TemplateName(FaceCellWave);
  69
  70
  71 /*---------------------------------------------------------------------------*\
  72                            Class FaceCellWave Declaration
  73 \*---------------------------------------------------------------------------*/
  74
  75 template <class Type>
  76 class FaceCellWave
  77 :
  78     public FaceCellWaveName
  79 {
  80     // Private data
  81
  82         //- Reference to mesh
  83         const polyMesh& mesh_;
  84
  85         //- Information for all faces
  86         UList<Type>& allFaceInfo_;
  87
  88         //- Information for all cells
  89         UList<Type>& allCellInfo_;
  90
  91         //- Has face changed
  92         boolList changedFace_;
  93
  94         //- List of changed faces
  95         labelList changedFaces_;
  96
  97         //- Number of changed faces
  98         label nChangedFaces_;
  99
 100         // Cells that have changed
 101         boolList changedCell_;
 102         labelList changedCells_;
 103         label nChangedCells_;
 104
 105         //- Contains cyclics
 106         bool hasCyclicPatches_;
 107
 108         //- Number of evaluations
 109         label nEvals_;
 110
 111         //- Number of unvisited cells/faces
 112         label nUnvisitedCells_;
 113         label nUnvisitedFaces_;
 114
 115         //- Iteration counter
 116         label iter_;
 117
 118
 119     // Static Functions
 120
 121         //- Write faces info
 122         static Ostream& writeFaces
 123         (
 124             const label nFaces,
 125             const labelList& faceLabels,
 126             const List<Type>& faceInfo,
 127             Ostream& os
 128         );
 129
 130         //- Read faces info
 131         static Istream& readFaces
 132         (
 133             label& nFaces,
 134             labelList& faceLabels,
 135             List<Type>& faceInfo,
 136             Istream& is
 137         );
 138
 139
 140     // Private Member Functions
 141
 142         //- Disallow default bitwise copy construct
 143         FaceCellWave(const FaceCellWave&);
 144
 145         //- Disallow default bitwise assignment
 146         void operator=(const FaceCellWave&);
 147
 148
 149         //- Updates cellInfo with information from neighbour. Updates all
 150         //  statistics.
 151         bool updateCell
 152         (
 153             const label cellI,
 154             const label neighbourFaceI,
 155             const Type& neighbourInfo,
 156             const scalar tol,
 157             Type& cellInfo
 158         );
 159
 160         //- Updates faceInfo with information from neighbour. Updates all
 161         //  statistics.
 162         bool updateFace
 163         (
 164             const label faceI,
 165             const label neighbourCellI,
 166             const Type& neighbourInfo,
 167             const scalar tol,
 168             Type& faceInfo
 169         );
 170
 171         //- Updates faceInfo with information from same face. Updates all
 172         //  statistics.
 173         bool updateFace
 174         (
 175             const label faceI,
 176             const Type& neighbourInfo,
 177             const scalar tol,
 178             Type& faceInfo
 179         );
 180
 181
 182         // Parallel, cyclic
 183
 184             //- Debugging: check info on both sides of cyclic
 185             void checkCyclic(const polyPatch& pPatch) const;
 186
 187             //- Has patches of certain type?
 188             bool hasPatchType(const word& nameOfType);
 189
 190             //- Merge received patch data into global data
 191             void mergeFaceInfo
 192             (
 193                 const polyPatch& patch,
 194                 const label nFaces,
 195                 const labelList&,
 196                 const List<Type>&,
 197                 const bool isParallel
 198             );
 199
 200             //- Extract info for single patch only
 201             label getChangedPatchFaces
 202             (
 203                 const polyPatch& patch,
 204                 const label startFaceI,
 205                 const label nFaces,
 206                 labelList& changedPatchFaces,
 207                 List<Type>& changedPatchFacesInfo
 208             ) const;
 209
 210             //- Handle leaving domain. Implementation referred to Type
 211             void leaveDomain
 212             (
 213                 const polyPatch& patch,
 214                 const label nFaces,
 215                 const labelList& faceLabels,
 216                 List<Type>& faceInfo
 217             ) const;
 218
 219             //- Handle leaving domain. Implementation referred to Type
 220             void enterDomain
 221             (
 222                 const polyPatch& patch,
 223                 const label nFaces,
 224                 const labelList& faceLabels,
 225                 List<Type>& faceInfo
 226             ) const;
 227
 228             //- Send info to neighbour
 229             void sendPatchInfo
 230             (
 231                 const label neighbour,
 232                 const label nFaces,
 233                 const labelList&,
 234                 const List<Type>&
 235             ) const;
 236
 237             //- Receive info from neighbour. Returns number of faces received.
 238             label receivePatchInfo
 239             (
 240                 const label neighbour,
 241                 labelList&,
 242                 List<Type>&
 243             ) const;
 244
 245             //- Offset face labels by constant value
 246             static void offset
 247             (
 248                 const polyPatch& patch,
 249                 const label off,
 250                 const label nFaces,
 251                 labelList& faces
 252             );
 253
 254             //- Apply transformation to Type
 255             void transform
 256             (
 257                 const tensorField& rotTensor,
 258                 const label nFaces,
 259                 List<Type>& faceInfo
 260             );
 261
 262             //- Merge data from across processor boundaries
 263             void handleProcPatches();
 264
 265             //- Merge data from across cyclics
 266             void handleCyclicPatches();
 267
 268
 269       // Private static data
 270
 271             static debug::tolerancesSwitch geomTol_;
 272             static debug::tolerancesSwitch propagationTol_;
 273
 274 public:
 275
 276     // Static Functions
 277
 278         //- Access to tolerance
 279         static scalar propagationTol()
 280         {
 281             return propagationTol_();
 282         }
 283
 284         //- Change tolerance
 285         static void setPropagationTol(const scalar tol)
 286         {
 287             propagationTol_ = tol;
 288         }
 289
 290
 291     // Constructors
 292
 293         // Construct from mesh. Use setFaceInfo and iterate() to do actual
 294         // calculation.
 295         FaceCellWave
 296         (
 297             const polyMesh&,
 298             UList<Type>& allFaceInfo,
 299             UList<Type>& allCellInfo
 300         );
 301
 302         //- Construct from mesh and list of changed faces with the Type
 303         //  for these faces. Iterates until nothing changes or maxIter reached.
 304         //  (maxIter can be 0)
 305         FaceCellWave
 306         (
 307             const polyMesh&,
 308             const labelList& initialChangedFaces,
 309             const List<Type>& changedFacesInfo,
 310             UList<Type>& allFaceInfo,
 311             UList<Type>& allCellInfo,
 312             const label maxIter
 313         );
 314
 315
 316     // Member Functions
 317
 318         // Access
 319
 320             //- Access allFaceInfo
 321             UList<Type>& allFaceInfo()
 322             {
 323                 return allFaceInfo_;
 324             }
 325
 326             //- Access allCellInfo
 327             UList<Type>& allCellInfo()
 328             {
 329                 return allCellInfo_;
 330             }
 331
 332             //- Access mesh
 333             const polyMesh& mesh() const
 334             {
 335                 return mesh_;
 336             }
 337
 338             //- Get number of unvisited cells, i.e. cells that were not (yet)
 339             //  reached from walking across mesh. This can happen from
 340             //  - not enough iterations done
 341             //  - a disconnected mesh
 342             //  - a mesh without walls in it
 343             label getUnsetCells() const;
 344
 345             //- Get number of unvisited faces
 346             label getUnsetFaces() const;
 347
 348
 349         // Edit
 350
 351             //- Set initial changed faces
 352             void setFaceInfo
 353             (
 354                 const labelList& changedFaces,
 355                 const List<Type>& changedFacesInfo
 356             );
 357
 358             //- Propagate from face to cell. Returns total number of cells
 359             //  (over all processors) changed.
 360             label faceToCell();
 361
 362             //- Propagate from cell to face. Returns total number of faces
 363             //  (over all processors) changed. (Faces on processorpatches are
 364             //  counted double)
 365             label cellToFace();
 366
 367             //- Iterate until no changes or maxIter reached. Returns number of
 368             //  unset cells (see getUnsetCells)
 369             label iterate(const label maxIter);
 370
 371 };
 372
 373
 374 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 375
 376 } // End namespace Foam
 377
 378
 379 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 380
 381 #ifdef NoRepository
 382 #   include "FaceCellWave.C"
 383 #endif
 384
 385 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 386
 387 #endif
 388
 389 // ************************************************************************* //