src/engine/engineTopoChangerMesh/thoboisSliding/thoboisSlidingCalculate.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 Class
  25     verticalValvesGambit
  26
  27 \*---------------------------------------------------------------------------*/
  28
  29 #include "thoboisSliding.H"
  30 #include "slidingInterface.H"
  31 #include "layerAdditionRemoval.H"
  32 #include "surfaceFields.H"
  33 #include "regionSplit.H"
  34 #include "componentMixedTetPolyPatchVectorField.H"
  35
  36 // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
  37
  38
  39 void Foam::thoboisSliding::calcMovingMaskTop(const label i) const
  40 {
  41     if (debug)
  42     {
  43         Info<< "void movingSquaresTM::calcMovingMasks() const : "
  44             << "Calculating point and cell masks"
  45             << endl;
  46     }
  47
  48     if (movingPointsMaskTopPtr_)
  49     {
  50         FatalErrorIn("void movingSquaresTM::calcMovingMasks() const")
  51             << "point mask already calculated"
  52             << abort(FatalError);
  53     }
  54
  55     // Set the point mask
  56     movingPointsMaskTopPtr_ = new scalarField(allPoints().size(), 0);
  57     scalarField& movingPointsMaskTop = *movingPointsMaskTopPtr_;
  58
  59     const cellList& c = cells();
  60     const faceList& f = allFaces();
  61
  62     const labelList& cellTopVAddr =
  63         cellZones()[cellZones().findZoneID("movingCellsTopZoneV"+ Foam::name(i+1))];
  64
  65     forAll (cellTopVAddr, cellI)
  66     {
  67         const cell& curCell = c[cellTopVAddr[cellI]];
  68
  69         forAll (curCell, faceI)
  70         {
  71             // Mark all the points as moving
  72             const face& curFace = f[curCell[faceI]];
  73
  74             forAll (curFace, pointI)
  75             {
  76                 movingPointsMaskTop[curFace[pointI]] = 1;
  77             }
  78         }
  79     }
  80
  81     const labelList& cellTopAddr =
  82         cellZones()[cellZones().findZoneID("movingCellsZoneV"+ Foam::name(i+1))];
  83
  84     forAll (cellTopAddr, cellI)
  85     {
  86         const cell& curCell = c[cellTopAddr[cellI]];
  87
  88         forAll (curCell, faceI)
  89         {
  90             // Mark all the points as moving
  91             const face& curFace = f[curCell[faceI]];
  92
  93             forAll (curFace, pointI)
  94             {
  95                 movingPointsMaskTop[curFace[pointI]] = 1;
  96             }
  97         }
  98     }
  99
 100
 101
 102 /*
 103     if(valves_[i].poppetPatchID().active())
 104     {
 105
 106         const word curtainCylZoneName
 107         (
 108             "curtainCylZoneV" + Foam::name(i + 1)
 109         );
 110
 111         const labelList& curtainCylAddr =
 112             faceZones()[faceZones().findZoneID(curtainCylZoneName)];
 113
 114         forAll (curtainCylAddr, faceI)
 115         {
 116             const face& curFace = f[curtainCylAddr[faceI]];
 117
 118             forAll (curFace, pointI)
 119             {
 120                 movingPointsMaskTop[curFace[pointI]] = 0;
 121             }
 122         }
 123
 124     }
 125 */
 126 }
 127
 128 // Return moving points mask.  Moving points marked with 1
 129 const Foam::scalarField& Foam::thoboisSliding::movingPointsMaskTop(const label i) const
 130 {
 131     if(movingPointsMaskTopPtr_)
 132     {
 133         movingPointsMaskTopPtr_ = NULL;
 134     }
 135
 136     if (!movingPointsMaskTopPtr_)
 137     {
 138         calcMovingMaskTop(i);
 139     }
 140
 141     return *movingPointsMaskTopPtr_;
 142 }
 143
 144
 145 void Foam::thoboisSliding::calcMovingMaskBottom(const label i) const
 146 {
 147     if (debug)
 148     {
 149         Info<< "void movingSquaresTM::calcMovingMasks() const : "
 150             << "Calculating point and cell masks"
 151             << endl;
 152     }
 153
 154     if (movingPointsMaskBottomPtr_)
 155     {
 156         FatalErrorIn("void movingSquaresTM::calcMovingMasks() const")
 157             << "point mask already calculated"
 158             << abort(FatalError);
 159     }
 160
 161     // Set the point mask
 162     movingPointsMaskBottomPtr_ = new scalarField(allPoints().size(), 0);
 163     scalarField& movingPointsMaskBottom = *movingPointsMaskBottomPtr_;
 164
 165     const cellList& c = cells();
 166     const faceList& f = allFaces();
 167
 168     const labelList& cellAddr =
 169         cellZones()[cellZones().findZoneID("movingCellsBottomZoneV"+ Foam::name(i+1))];
 170
 171     forAll (cellAddr, cellI)
 172     {
 173         const cell& curCell = c[cellAddr[cellI]];
 174
 175         forAll (curCell, faceI)
 176         {
 177             // Mark all the points as moving
 178             const face& curFace = f[curCell[faceI]];
 179
 180             forAll (curFace, pointI)
 181             {
 182                 {
 183                     movingPointsMaskBottom[curFace[pointI]] = 1;
 184                 }
 185             }
 186         }
 187     }
 188
 189 /*
 190     if(valves_[i].bottomPatchID().active())
 191     {
 192
 193         const word curtainCylZoneName
 194         (
 195             "curtainCylZoneV" + Foam::name(i + 1)
 196         );
 197
 198         const labelList& curtainCylAddr =
 199             faceZones()[faceZones().findZoneID(curtainCylZoneName)];
 200
 201         forAll (curtainCylAddr, faceI)
 202         {
 203             const face& curFace = f[curtainCylAddr[faceI]];
 204
 205             forAll (curFace, pointI)
 206             {
 207                 movingPointsMaskBottom[curFace[pointI]] = 0;
 208             }
 209         }
 210
 211     }
 212 */
 213 }
 214
 215 // Return moving points mask.  Moving points marked with 1
 216 const Foam::scalarField& Foam::thoboisSliding::movingPointsMaskBottom(const label i) const
 217 {
 218     if(movingPointsMaskBottomPtr_)
 219     {
 220         movingPointsMaskBottomPtr_ = NULL;
 221     }
 222
 223     if (!movingPointsMaskBottomPtr_)
 224     {
 225         calcMovingMaskBottom(i);
 226     }
 227
 228     return *movingPointsMaskBottomPtr_;
 229 }
 230
 231
 232 void Foam::thoboisSliding::calcMovingMaskPiston() const
 233 {
 234     if (debug)
 235     {
 236         Info<< "void movingSquaresTM::calcMovingMasks() const : "
 237             << "Calculating point and cell masks"
 238             << endl;
 239     }
 240
 241     if (movingPointsMaskPistonPtr_)
 242     {
 243         FatalErrorIn("void movingSquaresTM::calcMovingMasks() const")
 244             << "point mask already calculated"
 245             << abort(FatalError);
 246     }
 247
 248     // Set the point mask
 249     movingPointsMaskPistonPtr_ = new scalarField(allPoints().size(), 0);
 250     scalarField& movingPointsMaskPiston = *movingPointsMaskPistonPtr_;
 251
 252     const cellList& c = cells();
 253     const faceList& f = allFaces();
 254
 255     const labelList& cellAddr =
 256         cellZones()[cellZones().findZoneID("movingCellsPiston")];
 257
 258     forAll (cellAddr, cellI)
 259     {
 260         const cell& curCell = c[cellAddr[cellI]];
 261
 262         forAll (curCell, faceI)
 263         {
 264             // Mark all the points as moving
 265             const face& curFace = f[curCell[faceI]];
 266
 267             forAll (curFace, pointI)
 268             {
 269                 movingPointsMaskPiston[curFace[pointI]] = 1;
 270             }
 271         }
 272     }
 273 }
 274
 275 // Return moving points mask.  Moving points marked with 1
 276 const Foam::scalarField& Foam::thoboisSliding::movingPointsMaskPiston() const
 277 {
 278     if(movingPointsMaskPistonPtr_)
 279     {
 280         movingPointsMaskPistonPtr_ = NULL;
 281     }
 282
 283     if (!movingPointsMaskPistonPtr_)
 284     {
 285         calcMovingMaskPiston();
 286     }
 287
 288     return *movingPointsMaskPistonPtr_;
 289 }
 290
 291
 292
 293 void Foam::thoboisSliding::calcMovingMaskPistonValves(const label i) const
 294 {
 295     if (debug)
 296     {
 297         Info<< "void movingSquaresTM::calcMovingMasks() const : "
 298             << "Calculating point and cell masks"
 299             << endl;
 300     }
 301
 302     if (movingPointsMaskPistonValvesPtr_)
 303     {
 304         FatalErrorIn("void movingSquaresTM::calcMovingMasks() const")
 305             << "point mask already calculated"
 306             << abort(FatalError);
 307     }
 308
 309     // Set the point mask
 310     movingPointsMaskPistonValvesPtr_ = new scalarField(allPoints().size(), 0);
 311     scalarField& movingPointsMaskPistonValves = *movingPointsMaskPistonValvesPtr_;
 312
 313     const cellList& c = cells();
 314     const faceList& f = allFaces();
 315
 316     const labelList& cellAddr =
 317         cellZones()[cellZones().findZoneID("movingCellsPistonV" + Foam::name(i+1))];
 318
 319     forAll (cellAddr, cellI)
 320     {
 321         const cell& curCell = c[cellAddr[cellI]];
 322
 323         forAll (curCell, faceI)
 324         {
 325             // Mark all the points as moving
 326             const face& curFace = f[curCell[faceI]];
 327
 328             forAll (curFace, pointI)
 329             {
 330                 movingPointsMaskPistonValves[curFace[pointI]] = 1;
 331             }
 332         }
 333     }
 334 }
 335
 336 // Return moving points mask.  Moving points marked with 1
 337 const Foam::scalarField& Foam::thoboisSliding::movingPointsMaskPistonValves(const label i) const
 338 {
 339     if(movingPointsMaskPistonValvesPtr_)
 340     {
 341         movingPointsMaskPistonValvesPtr_ = NULL;
 342     }
 343
 344     if (!movingPointsMaskPistonValvesPtr_)
 345     {
 346         calcMovingMaskPistonValves(i);
 347     }
 348
 349     return *movingPointsMaskPistonValvesPtr_;
 350 }