src/meshTools/cellDist/patchWave/patchDataWave.C

   1 /*---------------------------------------------------------------------------*\
   2   =========                 |
   3   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
   4    \\    /   O peration     |
   5     \\  /    A nd           | Copyright (C) 1991-2009 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 \*---------------------------------------------------------------------------*/
  26
  27 #include "patchDataWave.H"
  28 #include "MeshWave.H"
  29
  30 // * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
  31
  32 // Set initial set of changed faces (= all wall faces)
  33 template<class TransferType>
  34 void Foam::patchDataWave<TransferType>::setChangedFaces
  35 (
  36     const labelHashSet& patchIDs,
  37     labelList& changedFaces,
  38     List<TransferType>& faceDist
  39 ) const
  40 {
  41     const polyMesh& mesh = cellDistFuncs::mesh();
  42
  43     label nChangedFaces = 0;
  44
  45     forAll(mesh.boundaryMesh(), patchI)
  46     {
  47         if (patchIDs.found(patchI))
  48         {
  49             const polyPatch& patch = mesh.boundaryMesh()[patchI];
  50
  51             const Field<Type>& patchField = initialPatchValuePtrs_[patchI];
  52
  53             forAll(patch.faceCentres(), patchFaceI)
  54             {
  55                 label meshFaceI = patch.start() + patchFaceI;
  56
  57                 changedFaces[nChangedFaces] = meshFaceI;
  58
  59                 faceDist[nChangedFaces] =
  60                     TransferType
  61                     (
  62                         patch.faceCentres()[patchFaceI],
  63                         patchField[patchFaceI],
  64                         0.0
  65                     );
  66
  67                 nChangedFaces++;
  68             }
  69         }
  70     }
  71 }
  72
  73
  74 // Copy from MeshWave data into *this (distance) and field_ (transported data)
  75 template<class TransferType>
  76 Foam::label Foam::patchDataWave<TransferType>::getValues
  77 (
  78     const MeshWave<TransferType>& waveInfo
  79 )
  80 {
  81     const polyMesh& mesh = cellDistFuncs::mesh();
  82
  83     const List<TransferType>& cellInfo = waveInfo.allCellInfo();
  84     const List<TransferType>& faceInfo = waveInfo.allFaceInfo();
  85
  86     label nIllegal = 0;
  87
  88     // Copy cell values
  89     distance_.setSize(cellInfo.size());
  90
  91     forAll(cellInfo, cellI)
  92     {
  93         const TransferType & wpn = cellInfo[cellI];
  94
  95         scalar dist = wpn.distSqr();
  96
  97         if (cellInfo[cellI].valid())
  98         {
  99             distance_[cellI] = Foam::sqrt(dist);
 100
 101             cellData_[cellI] = cellInfo[cellI].data();
 102         }
 103         else
 104         {
 105             // Illegal/unset value. What to do with data?
 106
 107             distance_[cellI] = dist;
 108
 109             //cellData_[cellI] = wallPoint::greatPoint;
 110             cellData_[cellI] = cellInfo[cellI].data();
 111
 112             nIllegal++;
 113         }
 114     }
 115
 116     // Copy boundary values
 117     forAll(patchDistance_, patchI)
 118     {
 119         const polyPatch& patch = mesh.boundaryMesh()[patchI];
 120
 121         // Allocate storage for patchDistance
 122         scalarField* patchFieldPtr = new scalarField(patch.size());
 123
 124         patchDistance_.set(patchI, patchFieldPtr);
 125
 126         scalarField& patchField = *patchFieldPtr;
 127
 128         // Allocate storage for patchData
 129         Field<Type>* patchDataFieldPtr = new Field<Type>(patch.size());
 130
 131         patchData_.set(patchI, patchDataFieldPtr);
 132
 133         Field<Type>& patchDataField = *patchDataFieldPtr;
 134
 135         // Copy distance and data
 136         forAll(patchField, patchFaceI)
 137         {
 138             label meshFaceI = patch.start() + patchFaceI;
 139
 140             scalar dist = faceInfo[meshFaceI].distSqr();
 141
 142             if (faceInfo[meshFaceI].valid())
 143             {
 144                 // Adding SMALL to avoid problems with /0 in the turbulence
 145                 // models
 146                 patchField[patchFaceI] = Foam::sqrt(dist) + SMALL;
 147
 148                 patchDataField[patchFaceI] = faceInfo[meshFaceI].data();
 149             }
 150             else
 151             {
 152                 // Illegal/unset value. What to do with data?
 153
 154                 patchField[patchFaceI] = dist;
 155
 156                 //patchDataField[patchFaceI] = wallPoint::greatPoint;
 157                 patchDataField[patchFaceI] = faceInfo[meshFaceI].data();
 158
 159                 nIllegal++;
 160             }
 161         }
 162     }
 163
 164     return nIllegal;
 165 }
 166
 167
 168 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
 169
 170 // Construct from components
 171 template<class TransferType>
 172 Foam::patchDataWave<TransferType>::patchDataWave
 173 (
 174     const polyMesh& mesh,
 175     const labelHashSet& patchIDs,
 176     const UPtrList<Field<Type> >& initialPatchValuePtrs,
 177     const bool correctWalls
 178 )
 179 :
 180     cellDistFuncs(mesh),
 181     patchIDs_(patchIDs),
 182     initialPatchValuePtrs_(initialPatchValuePtrs),
 183     correctWalls_(correctWalls),
 184     nUnset_(0),
 185     distance_(mesh.nCells()),
 186     patchDistance_(mesh.boundaryMesh().size()),
 187     cellData_(mesh.nCells()),
 188     patchData_(mesh.boundaryMesh().size())
 189 {
 190     patchDataWave<TransferType>::correct();
 191 }
 192
 193
 194 // * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
 195
 196 template<class TransferType>
 197 Foam::patchDataWave<TransferType>::~patchDataWave()
 198 {}
 199
 200
 201 // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
 202
 203 // Correct for mesh geom/topo changes
 204 template<class TransferType>
 205 void Foam::patchDataWave<TransferType>::correct()
 206 {
 207     //
 208     // Set initial changed faces: set TransferType for wall faces
 209     // to wall centre.
 210     //
 211
 212     // Count walls
 213     label nWalls = sumPatchSize(patchIDs_);
 214
 215     List<TransferType> faceDist(nWalls);
 216     labelList changedFaces(nWalls);
 217
 218     setChangedFaces(patchIDs_, changedFaces, faceDist);
 219
 220     //
 221     // Do calculate wall distance by 'growing' from faces.
 222     //
 223
 224     MeshWave<TransferType> waveInfo
 225     (
 226         mesh(),
 227         changedFaces,
 228         faceDist,
 229         mesh().globalData().nTotalCells() // max iterations
 230     );
 231
 232
 233     //
 234     // Copy distance into return field
 235     //
 236
 237     nUnset_ = getValues(waveInfo);
 238
 239     //
 240     // Correct wall cells for true distance
 241     //
 242
 243     if (correctWalls_)
 244     {
 245         Map<label> nearestFace(2 * nWalls);
 246
 247         // Get distance and indices of nearest face
 248         correctBoundaryFaceCells
 249         (
 250             patchIDs_,
 251             distance_,
 252             nearestFace
 253         );
 254
 255         correctBoundaryPointCells
 256         (
 257             patchIDs_,
 258             distance_,
 259             nearestFace
 260         );
 261
 262         // Transfer data from nearest face to cell
 263         const List<TransferType>& faceInfo = waveInfo.allFaceInfo();
 264
 265         const labelList wallCells(nearestFace.toc());
 266
 267         forAll(wallCells, wallCellI)
 268         {
 269             label cellI = wallCells[wallCellI];
 270
 271             label faceI = nearestFace[cellI];
 272
 273             cellData_[cellI] = faceInfo[faceI].data();
 274         }
 275     }
 276 }
 277
 278
 279 // ************************************************************************* //