src/engine/engineTopoChangerMesh/pistonSliding/pistonSlidingCalculate.C

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