src/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     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     const labelList& cellAddr =
 142         cellZones()[cellZones().findZoneID("movingCells")];
 143
 144     forAll (cellAddr, cellI)
 145     {
 146         const cell& curCell = c[cellAddr[cellI]];
 147
 148         forAll (curCell, faceI)
 149         {
 150             // Mark all the points as moving
 151             const face& curFace = f[curCell[faceI]];
 152
 153             forAll (curFace, pointI)
 154             {
 155                 movingPointsMask[curFace[pointI]] = 1;
 156             }
 157         }
 158     }
 159
 160     // Grab the ggi patches on the moving side
 161     wordList movingPatches(dict_.subDict("slider").lookup("moving"));
 162
 163     forAll (movingPatches, patchI)
 164     {
 165         polyPatchID movingSliderID
 166         (
 167             movingPatches[patchI],
 168             boundaryMesh()
 169         );
 170
 171         if (!movingSliderID.active())
 172         {
 173             FatalErrorIn("void mixerGgiFvMesh::calcMovingMasks() const")
 174                 << "Moving slider named " << movingPatches[patchI]
 175                 << " not found.  Valid patch names: "
 176                 << boundaryMesh().names() << abort(FatalError);
 177         }
 178
 179         const ggiPolyPatch& movingGgiPatch =
 180             refCast<const ggiPolyPatch>(boundaryMesh()[movingSliderID.index()]);
 181
 182         const labelList& movingSliderAddr = movingGgiPatch.zone();
 183
 184         forAll (movingSliderAddr, faceI)
 185         {
 186             const face& curFace = f[movingSliderAddr[faceI]];
 187
 188             forAll (curFace, pointI)
 189             {
 190                 movingPointsMask[curFace[pointI]] = 1;
 191             }
 192         }
 193     }
 194
 195     // Grab the ggi patches on the static side
 196     wordList staticPatches(dict_.subDict("slider").lookup("static"));
 197
 198     forAll (staticPatches, patchI)
 199     {
 200         polyPatchID staticSliderID
 201         (
 202             staticPatches[patchI],
 203             boundaryMesh()
 204         );
 205
 206         if (!staticSliderID.active())
 207         {
 208             FatalErrorIn("void mixerGgiFvMesh::calcMovingMasks() const")
 209                 << "Static slider named " << staticPatches[patchI]
 210                 << " not found.  Valid patch names: "
 211                 << boundaryMesh().names() << abort(FatalError);
 212         }
 213
 214         const ggiPolyPatch& staticGgiPatch =
 215             refCast<const ggiPolyPatch>(boundaryMesh()[staticSliderID.index()]);
 216
 217         const labelList& staticSliderAddr = staticGgiPatch.zone();
 218
 219         forAll (staticSliderAddr, faceI)
 220         {
 221             const face& curFace = f[staticSliderAddr[faceI]];
 222
 223             forAll (curFace, pointI)
 224             {
 225                 movingPointsMask[curFace[pointI]] = 0;
 226             }
 227         }
 228     }
 229 }
 230
 231
 232 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
 233
 234 // Construct from components
 235 Foam::mixerGgiFvMesh::mixerGgiFvMesh
 236 (
 237     const IOobject& io
 238 )
 239 :
 240     dynamicFvMesh(io),
 241     dict_
 242     (
 243         IOdictionary
 244         (
 245             IOobject
 246             (
 247                 "dynamicMeshDict",
 248                 time().constant(),
 249                 *this,
 250                 IOobject::MUST_READ,
 251                 IOobject::NO_WRITE
 252             )
 253         ).subDict(typeName + "Coeffs")
 254     ),
 255     csPtr_
 256     (
 257         coordinateSystem::New
 258         (
 259             "coordinateSystem",
 260             dict_.subDict("coordinateSystem")
 261         )
 262     ),
 263     rpm_(readScalar(dict_.lookup("rpm"))),
 264     movingPointsMaskPtr_(NULL)
 265 {
 266     addZonesAndModifiers();
 267
 268     Info<< "Mixer mesh:" << nl
 269         << "    origin: " << cs().origin() << nl
 270         << "    axis  : " << cs().axis() << nl
 271         << "    rpm   : " << rpm_ << endl;
 272 }
 273
 274
 275 // * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
 276
 277 Foam::mixerGgiFvMesh::~mixerGgiFvMesh()
 278 {
 279     deleteDemandDrivenData(movingPointsMaskPtr_);
 280 }
 281
 282
 283 // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
 284
 285 // Return moving points mask.  Moving points marked with 1
 286 const Foam::scalarField& Foam::mixerGgiFvMesh::movingPointsMask() const
 287 {
 288     if (!movingPointsMaskPtr_)
 289     {
 290         calcMovingMasks();
 291     }
 292
 293     return *movingPointsMaskPtr_;
 294 }
 295
 296
 297 bool Foam::mixerGgiFvMesh::update()
 298 {
 299      // Rotational speed needs to be converted from rpm
 300     movePoints
 301     (
 302         csPtr_->globalPosition
 303         (
 304             csPtr_->localPosition(allPoints())
 305           + vector(0, rpm_*360.0*time().deltaT().value()/60.0, 0)
 306             *movingPointsMask()
 307         )
 308     );
 309
 310     // The mesh is not morphing
 311     return false;
 312 }
 313
 314
 315 // ************************************************************************* //