src/dynamicMesh/topoChangerFvMesh/movingBodyTopoFvMesh/movingBodyTopoFvMesh.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 \*---------------------------------------------------------------------------*/
  26
  27 #include "movingBodyTopoFvMesh.H"
  28 #include "Time.H"
  29 #include "mapPolyMesh.H"
  30 #include "layerAdditionRemoval.H"
  31 #include "volMesh.H"
  32 #include "transformField.H"
  33 #include "addToRunTimeSelectionTable.H"
  34
  35 // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
  36
  37 namespace Foam
  38 {
  39     defineTypeNameAndDebug(movingBodyTopoFvMesh, 0);
  40
  41     addToRunTimeSelectionTable
  42     (
  43         topoChangerFvMesh,
  44         movingBodyTopoFvMesh,
  45         IOobject
  46     );
  47 }
  48
  49
  50 // * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
  51
  52 Foam::tmp<Foam::scalarField>
  53 Foam::movingBodyTopoFvMesh::calcMotionMask() const
  54 {
  55     Info<< "Updating vertex markup" << endl;
  56
  57     tmp<scalarField> tvertexMarkup(new scalarField(allPoints().size(), 0));
  58     scalarField& vertexMarkup = tvertexMarkup();
  59
  60     cellZoneID movingCellsID(movingCellsName_, cellZones());
  61
  62     // In order to do a correct update on a mask on processor boundaries,
  63     // Detection of moving cells should use patchNeighbourField for
  64     // processor (not coupled!) boundaries.  This is done by expanding
  65     // a moving cell set into a field and making sure that processor patch
  66     // points move in sync.  Not done at the moment, probably best to do
  67     // using parallel update of pointFields.  HJ, 19/Feb/2011
  68
  69     // If moving cells are found, perform mark-up
  70     if (movingCellsID.active())
  71     {
  72         // Get cell-point addressing
  73         const labelListList& cp = cellPoints();
  74
  75         // Get labels of all moving cells
  76         const labelList& movingCells = cellZones()[movingCellsID.index()];
  77
  78         forAll (movingCells, cellI)
  79         {
  80             const labelList& curCp = cp[movingCells[cellI]];
  81
  82             forAll (curCp, pointI)
  83             {
  84                 vertexMarkup[curCp[pointI]] = 1;
  85             }
  86         }
  87     }
  88
  89     faceZoneID frontFacesID(frontFacesName_, faceZones());
  90
  91     if (frontFacesID.active())
  92     {
  93         const faceZone& frontFaces = faceZones()[frontFacesID.index()];
  94
  95         const labelList& mp = frontFaces().meshPoints();
  96
  97         forAll (mp, mpI)
  98         {
  99             vertexMarkup[mp[mpI]] = 1;
 100         }
 101     }
 102
 103     faceZoneID backFacesID(backFacesName_, faceZones());
 104
 105     if (backFacesID.active())
 106     {
 107         const faceZone& backFaces = faceZones()[backFacesID.index()];
 108
 109         const labelList& mp = backFaces().meshPoints();
 110
 111         forAll (mp, mpI)
 112         {
 113             vertexMarkup[mp[mpI]] = 1;
 114         }
 115     }
 116
 117     return tvertexMarkup;
 118 }
 119
 120
 121 void Foam::movingBodyTopoFvMesh::addZonesAndModifiers()
 122 {
 123     // Add zones and modifiers for motion action
 124
 125     if (topoChanger_.size() > 0)
 126     {
 127         Info<< "void movingBodyTopoFvMesh::addZonesAndModifiers() : "
 128             << "Zones and modifiers already present.  Skipping."
 129             << endl;
 130
 131         return;
 132     }
 133
 134     // Add layer addition/removal interfaces
 135     topoChanger_.setSize(2);
 136     label nMods = 0;
 137
 138
 139     faceZoneID frontFacesID(frontFacesName_, faceZones());
 140     faceZoneID backFacesID(backFacesName_, faceZones());
 141
 142     if (frontFacesID.active())
 143     {
 144         const faceZone& frontFaces = faceZones()[frontFacesID.index()];
 145
 146         if (!frontFaces.empty())
 147         {
 148             topoChanger_.set
 149             (
 150                 nMods,
 151                 new layerAdditionRemoval
 152                 (
 153                     frontFacesName_ + "Layer",
 154                     nMods,
 155                     topoChanger_,
 156                     frontFacesName_,
 157                     readScalar
 158                     (
 159                         dict_.subDict("front").lookup("minThickness")
 160                     ),
 161                     readScalar
 162                     (
 163                         dict_.subDict("front").lookup("maxThickness")
 164                     )
 165                 )
 166             );
 167
 168             nMods++;
 169         }
 170     }
 171
 172     if (backFacesID.active())
 173     {
 174         const faceZone& backFaces = faceZones()[backFacesID.index()];
 175
 176         if (!backFaces.empty())
 177         {
 178             topoChanger_.set
 179             (
 180                 nMods,
 181                 new layerAdditionRemoval
 182                 (
 183                     backFacesName_ + "Layer",
 184                     nMods,
 185                     topoChanger_,
 186                     backFacesName_,
 187                     readScalar
 188                     (
 189                         dict_.subDict("back").lookup("minThickness")
 190                     ),
 191                     readScalar
 192                     (
 193                         dict_.subDict("back").lookup("maxThickness")
 194                     )
 195                 )
 196             );
 197
 198             nMods++;
 199         }
 200     }
 201
 202     topoChanger_.setSize(nMods);
 203
 204     reduce(nMods, sumOp<label>());
 205
 206     Info << "Adding " << nMods << " mesh modifiers" << endl;
 207
 208     // Write mesh and modifiers
 209     topoChanger_.write();
 210
 211     // No need to write the mesh - only modifiers are added.
 212     // HJ, 18/Feb/2011
 213 //     write();
 214 }
 215
 216
 217 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
 218
 219 // Construct from components
 220 Foam::movingBodyTopoFvMesh::movingBodyTopoFvMesh(const IOobject& io)
 221 :
 222     topoChangerFvMesh(io),
 223     dict_
 224     (
 225         IOdictionary
 226         (
 227             IOobject
 228             (
 229                 "dynamicMeshDict",
 230                 time().constant(),
 231                 *this,
 232                 IOobject::MUST_READ,
 233                 IOobject::NO_WRITE
 234             )
 235         ).subDict(typeName + "Coeffs")
 236     ),
 237     movingCellsName_(dict_.lookup("movingCells")),
 238     frontFacesName_(dict_.lookup("frontFaces")),
 239     backFacesName_(dict_.lookup("backFaces")),
 240     SBMFPtr_(solidBodyMotionFunction::New(dict_, time())),
 241     motionMask_()
 242 {
 243     addZonesAndModifiers();
 244     motionMask_ = calcMotionMask();
 245 }
 246
 247
 248 // * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
 249
 250 Foam::movingBodyTopoFvMesh::~movingBodyTopoFvMesh()
 251 {}
 252
 253
 254 // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
 255
 256 bool Foam::movingBodyTopoFvMesh::update()
 257 {
 258     // Store points to recreate mesh motion
 259     pointField oldPointsNew = allPoints();
 260     pointField newPoints = allPoints();
 261
 262     autoPtr<mapPolyMesh> topoChangeMap = topoChanger_.changeMesh();
 263
 264     bool localMeshChanged = topoChangeMap->morphing();
 265     bool globalMeshChanged = localMeshChanged;
 266     reduce(globalMeshChanged, orOp<bool>());
 267
 268     if (globalMeshChanged)
 269     {
 270         Pout<< "Topology change. Calculating motion point mask" << endl;
 271         motionMask_ = calcMotionMask();
 272     }
 273
 274     if (localMeshChanged)
 275     {
 276 //         // Map old points onto the new mesh
 277 //         pointField mappedOldPointsNew(allPoints().size());
 278 //         mappedOldPointsNew.map(oldPointsNew, topoChangeMap->pointMap());
 279
 280 //         movePoints(mappedOldPointsNew);
 281 //         resetMotion();
 282 //         setV0();
 283
 284         // Get new points from preMotion
 285         newPoints = topoChangeMap().preMotionPoints();
 286     }
 287 //     else
 288 //     {
 289 //         // No change, use old points
 290 //         movePoints(oldPointsNew);
 291 //         resetMotion();
 292 //         setV0();
 293 //     }
 294
 295     // Calculate new points using a velocity transformation
 296     newPoints += motionMask_*
 297         transform(SBMFPtr_().velocity(), newPoints)*time().deltaT().value();
 298
 299     Info << "Executing mesh motion" << endl;
 300     movePoints(newPoints);
 301
 302     return localMeshChanged;
 303 }
 304
 305
 306 // ************************************************************************* //