src/fvMotionSolver/motionDiffusivity/inverseFaceDistance/inverseFaceDistanceDiffusivity.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 "inverseFaceDistanceDiffusivity.H"
  28 #include "addToRunTimeSelectionTable.H"
  29 #include "HashSet.H"
  30 #include "wallPoint.H"
  31 #include "MeshWave.H"
  32
  33 // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
  34
  35 namespace Foam
  36 {
  37     defineTypeNameAndDebug(inverseFaceDistanceDiffusivity, 0);
  38
  39     addToRunTimeSelectionTable
  40     (
  41         motionDiffusivity,
  42         inverseFaceDistanceDiffusivity,
  43         Istream
  44     );
  45 }
  46
  47
  48 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
  49
  50 Foam::inverseFaceDistanceDiffusivity::inverseFaceDistanceDiffusivity
  51 (
  52     const fvMotionSolver& mSolver,
  53     Istream& mdData
  54 )
  55 :
  56     uniformDiffusivity(mSolver, mdData),
  57     patchNames_(mdData)
  58 {
  59     correct();
  60 }
  61
  62
  63 // * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
  64
  65 Foam::inverseFaceDistanceDiffusivity::~inverseFaceDistanceDiffusivity()
  66 {}
  67
  68
  69 // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
  70
  71 void Foam::inverseFaceDistanceDiffusivity::correct()
  72 {
  73     const polyMesh& mesh = mSolver().mesh();
  74     const polyBoundaryMesh& bdry = mesh.boundaryMesh();
  75
  76     labelHashSet patchSet(bdry.size());
  77
  78     label nPatchFaces = 0;
  79
  80     forAll (patchNames_, i)
  81     {
  82         label pID = bdry.findPatchID(patchNames_[i]);
  83
  84         if (pID > -1)
  85         {
  86             patchSet.insert(pID);
  87             nPatchFaces += bdry[pID].size();
  88         }
  89     }
  90
  91     List<wallPoint> faceDist(nPatchFaces);
  92     labelList changedFaces(nPatchFaces);
  93
  94     nPatchFaces = 0;
  95
  96     forAllConstIter(labelHashSet, patchSet, iter)
  97     {
  98         const polyPatch& patch = bdry[iter.key()];
  99
 100         const vectorField::subField fc = patch.faceCentres();
 101
 102         forAll(fc, patchFaceI)
 103         {
 104             changedFaces[nPatchFaces] = patch.start() + patchFaceI;
 105
 106             faceDist[nPatchFaces] = wallPoint(fc[patchFaceI], 0);
 107
 108             nPatchFaces++;
 109         }
 110     }
 111     faceDist.setSize(nPatchFaces);
 112     changedFaces.setSize(nPatchFaces);
 113
 114     MeshWave<wallPoint> waveInfo
 115     (
 116         mesh,
 117         changedFaces,
 118         faceDist,
 119         mesh.globalData().nTotalCells() // max iterations
 120     );
 121
 122     const List<wallPoint>& faceInfo = waveInfo.allFaceInfo();
 123     const List<wallPoint>& cellInfo = waveInfo.allCellInfo();
 124
 125     for (label faceI=0; faceI<mesh.nInternalFaces(); faceI++)
 126     {
 127         scalar dist = faceInfo[faceI].distSqr();
 128
 129         faceDiffusivity_[faceI] = 1.0/sqrt(dist);
 130     }
 131
 132     forAll(faceDiffusivity_.boundaryField(), patchI)
 133     {
 134         fvsPatchScalarField& bfld = faceDiffusivity_.boundaryField()[patchI];
 135
 136         const unallocLabelList& faceCells = bfld.patch().faceCells();
 137
 138         if (patchSet.found(patchI))
 139         {
 140             forAll(bfld, i)
 141             {
 142                 scalar dist = cellInfo[faceCells[i]].distSqr();
 143                 bfld[i] = 1.0/sqrt(dist);
 144             }
 145         }
 146         else
 147         {
 148             label start = bfld.patch().patch().start();
 149
 150             forAll(bfld, i)
 151             {
 152                 scalar dist = faceInfo[start+i].distSqr();
 153                 bfld[i] = 1.0/sqrt(dist);
 154             }
 155         }
 156     }
 157 }
 158
 159
 160 // ************************************************************************* //