src/dynamicMesh/dynamicFvMesh/mixerGgiFvMesh/mixerGgiFvMesh.C

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