src/dynamicMesh/dynamicFvMesh/mixerGgiFvMesh/mixerGgiFvMesh.C

   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 \*---------------------------------------------------------------------------*/
  25
  26 #include "mixerGgiFvMesh.H"
  27 #include "foamTime.H"
  28 #include "regionSplit.H"
  29 #include "ggiPolyPatch.H"
  30 #include "polyPatchID.H"
  31 #include "addToRunTimeSelectionTable.H"
  32 #include "mapPolyMesh.H"
  33
  34 // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
  35
  36 namespace Foam
  37 {
  38     defineTypeNameAndDebug(mixerGgiFvMesh, 0);
  39     addToRunTimeSelectionTable(dynamicFvMesh, mixerGgiFvMesh, IOobject);
  40 }
  41
  42
  43 // * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
  44
  45 void Foam::mixerGgiFvMesh::addZonesAndModifiers()
  46 {
  47     // Add zones and modifiers for motion action
  48
  49     if (cellZones().size() > 0)
  50     {
  51         Info<< "void mixerGgiFvMesh::addZonesAndModifiers() : "
  52             << "Zones and modifiers already present.  Skipping."
  53             << endl;
  54
  55         return;
  56     }
  57
  58     Info<< "Time = " << time().timeName() << endl
  59         << "Adding zones and modifiers to the mesh" << endl;
  60
  61     // Add zones
  62     List<pointZone*> pz(0);
  63     List<faceZone*> fz(0);
  64     List<cellZone*> cz(1);
  65
  66     // Copy the face zones associated with the GGI interfaces
  67     if (faceZones().size() > 0)
  68     {
  69         // Copy face zones
  70         Info << "Copying existing face zones" << endl;
  71
  72         fz.setSize(faceZones().size());
  73
  74         forAll (faceZones(), i)
  75         {
  76             fz[i] = faceZones()[i].clone(faceZones()).ptr();
  77         }
  78     }
  79
  80     regionSplit rs(*this);
  81
  82     // Get the region of the cell containing the origin.
  83     label originRegion = rs[findNearestCell(cs().origin())];
  84
  85     labelList movingCells(nCells());
  86     label nMovingCells = 0;
  87
  88     forAll(rs, cellI)
  89     {
  90         if (rs[cellI] == originRegion)
  91         {
  92             movingCells[nMovingCells] = cellI;
  93             nMovingCells++;
  94         }
  95     }
  96
  97     movingCells.setSize(nMovingCells);
  98     Info << "Number of cells in the moving region: " << nMovingCells << endl;
  99
 100     cz[0] = new cellZone
 101     (
 102         "movingCells",
 103         movingCells,
 104         0,
 105         cellZones()
 106     );
 107
 108     Info << "Adding point, face and cell zones" << endl;
 109     removeZones();
 110     addZones(pz, fz, cz);
 111
 112     // Write mesh
 113     syncUpdateMesh();
 114     write();
 115 }
 116
 117
 118 void Foam::mixerGgiFvMesh::calcMovingMasks() const
 119 {
 120     if (debug)
 121     {
 122         Info<< "void mixerGgiFvMesh::calcMovingMasks() const : "
 123             << "Calculating point and cell masks"
 124             << endl;
 125     }
 126
 127     if (movingPointsMaskPtr_)
 128     {
 129         FatalErrorIn("void mixerGgiFvMesh::calcMovingMasks() const")
 130             << "point mask already calculated"
 131             << abort(FatalError);
 132     }
 133
 134     // Set the point mask
 135     movingPointsMaskPtr_ = new scalarField(allPoints().size(), 0);
 136     scalarField& movingPointsMask = *movingPointsMaskPtr_;
 137
 138     const cellList& c = cells();
 139     const faceList& f = allFaces();
 140
 141     label movingCellsID = cellZones().findZoneID("movingCells");
 142
 143     if (movingCellsID < 0)
 144     {
 145         FatalErrorIn("void mixerGgiFvMesh::calcMovingMasks() const")
 146             << "Cannot find moving cell zone ID"
 147             << abort(FatalError);
 148     }
 149
 150     const labelList& cellAddr = cellZones()[movingCellsID];
 151
 152     forAll (cellAddr, cellI)
 153     {
 154         const cell& curCell = c[cellAddr[cellI]];
 155
 156         forAll (curCell, faceI)
 157         {
 158             // Mark all the points as moving
 159             const face& curFace = f[curCell[faceI]];
 160
 161             forAll (curFace, pointI)
 162             {
 163                 movingPointsMask[curFace[pointI]] = 1;
 164             }
 165         }
 166     }
 167
 168     // Grab the ggi patches on the moving side
 169     wordList movingPatches(dict_.subDict("slider").lookup("moving"));
 170
 171     forAll (movingPatches, patchI)
 172     {
 173         const label movingSliderID =
 174             boundaryMesh().findPatchID(movingPatches[patchI]);
 175
 176         if (movingSliderID < 0)
 177         {
 178             FatalErrorIn("void mixerGgiFvMesh::calcMovingMasks() const")
 179                 << "Moving slider named " << movingPatches[patchI]
 180                 << " not found.  Valid patch names: "
 181                 << boundaryMesh().names() << abort(FatalError);
 182         }
 183
 184         const ggiPolyPatch& movingGgiPatch =
 185             refCast<const ggiPolyPatch>(boundaryMesh()[movingSliderID]);
 186
 187         const labelList& movingSliderAddr = movingGgiPatch.zone();
 188
 189         forAll (movingSliderAddr, faceI)
 190         {
 191             const face& curFace = f[movingSliderAddr[faceI]];
 192
 193             forAll (curFace, pointI)
 194             {
 195                 movingPointsMask[curFace[pointI]] = 1;
 196             }
 197         }
 198     }
 199
 200     // Grab the ggi patches on the static side
 201     wordList staticPatches(dict_.subDict("slider").lookup("static"));
 202
 203     forAll (staticPatches, patchI)
 204     {
 205         const label staticSliderID =
 206             boundaryMesh().findPatchID(staticPatches[patchI]);
 207
 208         if (staticSliderID < 0)
 209         {
 210             FatalErrorIn("void mixerGgiFvMesh::calcMovingMasks() const")
 211                 << "Static slider named " << staticPatches[patchI]
 212                 << " not found.  Valid patch names: "
 213                 << boundaryMesh().names() << abort(FatalError);
 214         }
 215
 216         const ggiPolyPatch& staticGgiPatch =
 217             refCast<const ggiPolyPatch>(boundaryMesh()[staticSliderID]);
 218
 219         const labelList& staticSliderAddr = staticGgiPatch.zone();
 220
 221         forAll (staticSliderAddr, faceI)
 222         {
 223             const face& curFace = f[staticSliderAddr[faceI]];
 224
 225             forAll (curFace, pointI)
 226             {
 227                 movingPointsMask[curFace[pointI]] = 0;
 228             }
 229         }
 230     }
 231 }
 232
 233
 234 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
 235
 236 // Construct from components
 237 Foam::mixerGgiFvMesh::mixerGgiFvMesh
 238 (
 239     const IOobject& io
 240 )
 241 :
 242     dynamicFvMesh(io),
 243     dict_
 244     (
 245         IOdictionary
 246         (
 247             IOobject
 248             (
 249                 "dynamicMeshDict",
 250                 time().constant(),
 251                 *this,
 252                 IOobject::MUST_READ,
 253                 IOobject::NO_WRITE
 254             )
 255         ).subDict(typeName + "Coeffs")
 256     ),
 257     cs_
 258     (
 259         "coordinateSystem",
 260         dict_.subDict("coordinateSystem")
 261     ),
 262     rpm_(readScalar(dict_.lookup("rpm"))),
 263     movingPointsMaskPtr_(NULL)
 264 {
 265     // Make sure the coordinate system does not operate in degrees
 266     // Bug fix, HJ, 3/Oct/2011
 267     if (!cs_.inDegrees())
 268     {
 269         WarningIn("mixerGgiFvMesh::mixerGgiFvMesh(const IOobject& io)")
 270             << "Mixer coordinate system is set to operate in radians.  "
 271             << "Changing to rad for correct calculation of angular velocity."
 272             << nl
 273             << "To remove this message please add entry" << nl << nl
 274             << "inDegrees true;" << nl << nl
 275             << "to the specification of the coordinate system"
 276             << endl;
 277
 278         cs_.inDegrees() = true;
 279     }
 280
 281     addZonesAndModifiers();
 282
 283     Info<< "Mixer mesh:" << nl
 284         << "    origin: " << cs().origin() << nl
 285         << "    axis  : " << cs().axis() << nl
 286         << "    rpm   : " << rpm_ << endl;
 287 }
 288
 289
 290 // * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
 291
 292 Foam::mixerGgiFvMesh::~mixerGgiFvMesh()
 293 {
 294     deleteDemandDrivenData(movingPointsMaskPtr_);
 295 }
 296
 297
 298 // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
 299
 300 // Return moving points mask.  Moving points marked with 1
 301 const Foam::scalarField& Foam::mixerGgiFvMesh::movingPointsMask() const
 302 {
 303     if (!movingPointsMaskPtr_)
 304     {
 305         calcMovingMasks();
 306     }
 307
 308     return *movingPointsMaskPtr_;
 309 }
 310
 311
 312 bool Foam::mixerGgiFvMesh::update()
 313 {
 314     // Rotational speed needs to be converted from rpm
 315     movePoints
 316     (
 317         cs_.globalPosition
 318         (
 319             cs_.localPosition(allPoints())
 320           + vector(0, rpm_*360.0*time().deltaT().value()/60.0, 0)
 321             *movingPointsMask()
 322         )
 323     );
 324
 325     // The mesh is not morphing, but flux re-calculation is required
 326     // HJ, 25/Jan/2016
 327     return true;
 328 }
 329
 330
 331 // ************************************************************************* //