src/finiteVolume/interpolation/pointVolInterpolation/pointVolInterpolation.C

   1 /*---------------------------------------------------------------------------*\
   2   =========                 |
   3   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
   4    \\    /   O peration     |
   5     \\  /    A nd           | Copyright held by original author
   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 Class
  26     pointVolInterpolation
  27
  28 Description
  29
  30 \*---------------------------------------------------------------------------*/
  31
  32 #include "pointVolInterpolation.H"
  33 #include "fvMesh.H"
  34 #include "pointFields.H"
  35 #include "volFields.H"
  36 #include "emptyFvPatch.H"
  37 #include "SubField.H"
  38 #include "demandDrivenData.H"
  39 #include "globalMeshData.H"
  40
  41 // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
  42
  43 namespace Foam
  44 {
  45     defineTypeNameAndDebug(pointVolInterpolation, 0);
  46 }
  47
  48
  49 // * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
  50
  51 void Foam::pointVolInterpolation::makeWeights() const
  52 {
  53     if (volWeightsPtr_)
  54     {
  55         FatalErrorIn("pointVolInterpolation::makeWeights() const")
  56             << "weighting factors already calculated"
  57             << abort(FatalError);
  58     }
  59
  60     if (debug)
  61     {
  62         Info<< "pointVolInterpolation::makeWeights() : "
  63             << "constructing weighting factors"
  64             << endl;
  65     }
  66
  67     const pointField& points = vMesh().points();
  68     const labelListList& cellPoints = vMesh().cellPoints();
  69     const vectorField& cellCentres = vMesh().cellCentres();
  70
  71     // Allocate storage for weighting factors
  72     volWeightsPtr_ = new FieldField<Field, scalar>(cellCentres.size());
  73     FieldField<Field, scalar>& weightingFactors = *volWeightsPtr_;
  74
  75     forAll(weightingFactors, pointi)
  76     {
  77         weightingFactors.set
  78         (
  79             pointi,
  80             new scalarField(cellPoints[pointi].size())
  81         );
  82     }
  83
  84
  85     // Calculate inverse distances between points and cell centres
  86     // and store in weighting factor array
  87     forAll(cellCentres, cellI)
  88     {
  89         const labelList& curCellPoints = cellPoints[cellI];
  90
  91         forAll(curCellPoints, cellPointI)
  92         {
  93             weightingFactors[cellI][cellPointI] = 1.0/
  94                 mag
  95                 (
  96                     cellCentres[cellI] - points[curCellPoints[cellPointI]]
  97                 );
  98         }
  99     }
 100
 101     scalarField pointVolSumWeights(cellCentres.size(), 0);
 102
 103     // Calculate weighting factors using inverse distance weighting
 104     forAll(cellCentres, cellI)
 105     {
 106         const labelList& curCellPoints = cellPoints[cellI];
 107
 108         forAll(curCellPoints, cellPointI)
 109         {
 110             pointVolSumWeights[cellI] += weightingFactors[cellI][cellPointI];
 111         }
 112     }
 113
 114     forAll(cellCentres, cellI)
 115     {
 116         const labelList& curCellPoints = cellPoints[cellI];
 117
 118         forAll(curCellPoints, cellPointI)
 119         {
 120             weightingFactors[cellI][cellPointI] /= pointVolSumWeights[cellI];
 121         }
 122     }
 123
 124     if (debug)
 125     {
 126         Info<< "pointVolInterpolation::makeWeights() : "
 127             << "finished constructing weighting factors"
 128             << endl;
 129     }
 130 }
 131
 132
 133 // Do what is neccessary if the mesh has changed topology
 134 void Foam::pointVolInterpolation::clearAddressing() const
 135 {
 136     deleteDemandDrivenData(patchInterpolatorsPtr_);
 137 }
 138
 139
 140 // Do what is neccessary if the mesh has moved
 141 void Foam::pointVolInterpolation::clearGeom() const
 142 {
 143     deleteDemandDrivenData(volWeightsPtr_);
 144 }
 145
 146
 147 const Foam::PtrList<Foam::primitivePatchInterpolation>&
 148 Foam::pointVolInterpolation::patchInterpolators() const
 149 {
 150     if (!patchInterpolatorsPtr_)
 151     {
 152         const fvBoundaryMesh& bdry = vMesh().boundary();
 153
 154         patchInterpolatorsPtr_ =
 155             new PtrList<primitivePatchInterpolation>(bdry.size());
 156
 157         forAll (bdry, patchI)
 158         {
 159             patchInterpolatorsPtr_->set
 160             (
 161                 patchI,
 162                 new primitivePatchInterpolation(bdry[patchI].patch())
 163             );
 164         }
 165     }
 166
 167     return *patchInterpolatorsPtr_;
 168 }
 169
 170
 171 // * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * * //
 172
 173 Foam::pointVolInterpolation::pointVolInterpolation
 174 (
 175  const pointMesh& pm,
 176     const fvMesh& vm
 177 )
 178 :
 179     pointMesh_(pm),
 180     fvMesh_(vm),
 181     volWeightsPtr_(NULL),
 182     patchInterpolatorsPtr_(NULL)
 183 {}
 184
 185
 186 // * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * * //
 187
 188 Foam::pointVolInterpolation::~pointVolInterpolation()
 189 {
 190     clearAddressing();
 191     clearGeom();
 192 }
 193
 194
 195 // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
 196
 197 // Return point weights
 198 const Foam::FieldField<Foam::Field, Foam::scalar>&
 199 Foam::pointVolInterpolation::volWeights() const
 200 {
 201     // If weighting factor array not present then construct
 202     if (!volWeightsPtr_)
 203     {
 204         makeWeights();
 205     }
 206
 207     return *volWeightsPtr_;
 208 }
 209
 210
 211 // Do what is neccessary if the mesh has moved
 212 void Foam::pointVolInterpolation::updateTopology()
 213 {
 214     clearAddressing();
 215     clearGeom();
 216 }
 217
 218
 219 // Do what is neccessary if the mesh has moved
 220 bool Foam::pointVolInterpolation::movePoints()
 221 {
 222     clearGeom();
 223
 224     return true;
 225 }
 226
 227
 228 // ************************************************************************* //