src/dbns/multigrid/mgFieldLevel/coarseMgFieldLevel.H

   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     Foam::coarseMgFieldLevel
  26
  27 Description
  28     Coarse level of multigrid hierarchy, holding fields
  29
  30 SourceFiles
  31     coarseMgFieldLevel.C
  32
  33 \*---------------------------------------------------------------------------*/
  34
  35 #ifndef coarseMgFieldLevel_H
  36 #define coarseMgFieldLevel_H
  37
  38 #include "mgFieldLevel.H"
  39 #include "mgMeshLevel.H"
  40 #include "coarseMgMeshLevel.H"
  41
  42 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
  43
  44 namespace Foam
  45 {
  46
  47 /*---------------------------------------------------------------------------*\
  48                        Class coarseMgFieldLevel Declaration
  49 \*---------------------------------------------------------------------------*/
  50
  51 class coarseMgFieldLevel
  52 :
  53     public mgFieldLevel
  54 {
  55     // Private data
  56
  57         // Mesh levels
  58
  59             //- Reference to the current mesh level
  60             //  corresponding to the current field level
  61             const mgMeshLevel& meshLevel_;
  62
  63             //- Reference to fine data level
  64            const mgFieldLevel& fineFieldLevel_;
  65
  66
  67         // Geometry
  68
  69             //- Number of cells
  70             label nCells_;
  71
  72             //- Number of internal face
  73             label nInternalFaces_;
  74
  75
  76         // Fields
  77
  78             //- Coarse p
  79             scalarField p_;
  80
  81             //- Coarse U
  82             vectorField U_;
  83
  84             //- Coarse T
  85             scalarField T_;
  86
  87
  88         // Thermodynamics fields
  89
  90             //- Coarse Cv
  91             scalarField Cv_;
  92
  93             //- Coarse R
  94             scalarField R_;
  95
  96
  97         // Residuals
  98
  99             //- Coarse rhoRes
 100             scalarField rhoRes_;
 101
 102             //- Coarse rhoURes
 103             vectorField rhoURes_;
 104
 105             //- Coarse rhoERes
 106             scalarField rhoERes_;
 107
 108
 109         // Fluxes
 110
 111             //- Fine rhoFlux
 112             surfaceScalarField& rhoFlux_;
 113
 114             //- Fine rhoUFlux
 115             surfaceVectorField& rhoUFlux_;
 116
 117             //- Fine rhoEFlux
 118             surfaceScalarField& rhoEFlux_;
 119
 120             //- Coarse rho
 121             scalarField rho_;
 122
 123             //- Coarse rhoU
 124             vectorField rhoU_;
 125
 126             //- Coarse rhoE
 127             scalarField rhoE_;
 128
 129
 130         //- Helper data
 131         label level_;
 132
 133
 134     // Private Member Functions
 135
 136         //- Disallow default bitwise copy construct
 137         coarseMgFieldLevel(const coarseMgFieldLevel&);
 138
 139         //- Disallow default bitwise assignment
 140         void operator=(const coarseMgFieldLevel&);
 141
 142         // Restriction operators used for interpolation
 143        template <typename T>
 144        void interpolate
 145        (
 146            Field<T>& c,
 147            Field<T> f
 148        )
 149        {
 150            c = pTraits<T>::zero;
 151            f *= meshLevel_.fineLevel().cellVolumes();
 152            fineFieldLevel_.restrict(c, f);
 153            c /= meshLevel_.cellVolumes();
 154        }
 155
 156
 157 public:
 158
 159         //- Runtime type information
 160         TypeName("coarseMgFieldLevel");
 161
 162
 163     // Constructors
 164
 165         //- Construct from fine mgFieldLevel
 166         coarseMgFieldLevel
 167         (
 168             const mgMeshLevel& coarseMeshLevel,
 169             const mgFieldLevel& fineFieldLevel
 170         )
 171         :
 172             meshLevel_(coarseMeshLevel),
 173             fineFieldLevel_(fineFieldLevel),
 174             nCells_(coarseMeshLevel.nCells()),
 175             nInternalFaces_(coarseMeshLevel.nInternalFaces()),
 176             p_(scalarField(coarseMeshLevel.nCells())),
 177             U_(vectorField(coarseMeshLevel.nCells())),
 178             T_(scalarField(coarseMeshLevel.nCells())),
 179             Cv_(scalarField(coarseMeshLevel.nCells())),
 180             R_(scalarField(coarseMeshLevel.nCells())),
 181             rhoRes_(scalarField(coarseMeshLevel.nCells())),
 182             rhoURes_(vectorField(coarseMeshLevel.nCells())),
 183             rhoERes_(scalarField(coarseMeshLevel.nCells())),
 184             rhoFlux_(fineFieldLevel.rhoFlux()),
 185             rhoUFlux_(fineFieldLevel.rhoUFlux()),
 186             rhoEFlux_(fineFieldLevel.rhoEFlux()),
 187             rho_(scalarField(coarseMeshLevel.nCells())),
 188             rhoU_(vectorField(coarseMeshLevel.nCells())),
 189             rhoE_(scalarField(coarseMeshLevel.nCells())),
 190             level_(fineFieldLevel.level())
 191         {
 192             ++level_;
 193
 194             interpolate(p_, fineFieldLevel_.pVar());
 195             interpolate(U_, fineFieldLevel_.UVar());
 196             interpolate(T_, fineFieldLevel_.TVar());
 197
 198             interpolate(Cv_, fineFieldLevel_.CvVar());
 199             interpolate(R_, fineFieldLevel_.RVar());
 200
 201             interpolate(rho_, fineFieldLevel_.rhoVar());
 202             interpolate(rhoU_, fineFieldLevel_.rhoUVar());
 203             interpolate(rhoE_, fineFieldLevel_.rhoEVar());
 204
 205             if (level_ == 1)
 206             {
 207                 const scalarField& fineVol =
 208                     meshLevel_.fineLevel().cellVolumes();
 209
 210                 rhoRes_ = 0;
 211                 scalarField fineRhoRes = fineFieldLevel_.rhoResVar();
 212                 fineRhoRes *= fineVol;
 213                 fineFieldLevel_.restrict(rhoRes_, fineRhoRes);
 214
 215                 rhoURes_ = vector::zero;
 216                 vectorField fineRhoURes = fineFieldLevel_.rhoUResVar();
 217                 fineRhoURes *= fineVol;
 218                 fineFieldLevel_.restrict(rhoURes_, fineRhoURes);
 219
 220                 rhoERes_ = 0;
 221                 scalarField fineRhoERes = fineFieldLevel_.rhoEResVar();
 222                 fineRhoERes *= fineVol;
 223                 fineFieldLevel_.restrict(rhoERes_, fineRhoERes);
 224             }
 225             else
 226             {
 227                 rhoRes_ = 0;
 228                 fineFieldLevel_.restrict
 229                 (
 230                     rhoRes_,
 231                     fineFieldLevel_.rhoResVar()
 232                 );
 233
 234                 rhoURes_ = vector::zero;
 235                 fineFieldLevel_.restrict
 236                 (
 237                      rhoURes_,
 238                      fineFieldLevel_.rhoUResVar()
 239                 );
 240
 241                 rhoERes_ = 0;
 242                 fineFieldLevel_.restrict
 243                 (
 244                     rhoERes_,
 245                     fineFieldLevel_.rhoEResVar()
 246                 );
 247             }
 248         }
 249
 250
 251     //- Destructor
 252     virtual ~coarseMgFieldLevel()
 253     {}
 254
 255
 256     // Member Functions
 257
 258         // Access
 259
 260             //- Is this the finest level?
 261             virtual bool finest() const
 262             {
 263                 return meshLevel_.finest();
 264             }
 265
 266
 267         // Addressing
 268
 269             //- Return number of cells
 270             virtual label nCells() const
 271             {
 272                 return nCells_;
 273             }
 274
 275             //- Return number of internal faces
 276             virtual label nInternalFaces() const
 277             {
 278                 return nInternalFaces_;
 279             }
 280
 281             //- Return number of patches
 282             virtual label nPatches() const
 283             {
 284                 return fineFieldLevel_.nPatches();
 285             }
 286
 287             //- Access to child array
 288             virtual const labelList& child() const
 289             {
 290                 return meshLevel_.child();
 291             }
 292
 293             //- Access to fine level
 294             virtual const mgFieldLevel& fineLevel() const
 295             {
 296                 return fineFieldLevel_;
 297             }
 298
 299
 300         // Field data
 301
 302             //- Return p
 303             virtual const scalarField& pVar() const
 304             {
 305                 return p_;
 306             }
 307
 308             //- Access to fine level pressure field
 309             virtual const volScalarField& p() const
 310             {
 311                 return fineFieldLevel_.p();
 312             }
 313
 314             //- Return p value for patches on fine level
 315             virtual const scalarField& patchP
 316             (
 317                 const label patchNo
 318             ) const
 319             {
 320                 return fineFieldLevel_.patchP(patchNo);
 321             }
 322
 323              //- Return U
 324             virtual const vectorField& UVar() const
 325             {
 326                 return U_;
 327             }
 328
 329             virtual const volVectorField& U() const
 330             {
 331                 return fineFieldLevel_.U();
 332             }
 333
 334             //- Return U value for patches
 335             virtual const vectorField& patchU
 336             (
 337                 const label patchNo
 338             ) const
 339             {
 340                 return fineFieldLevel_.patchU(patchNo);
 341             }
 342
 343             //- Return T
 344             virtual const scalarField& TVar() const
 345             {
 346                 return T_;
 347             }
 348
 349             virtual const volScalarField& T() const
 350             {
 351                 return fineFieldLevel_.T();
 352             }
 353
 354             //- Return T value for patches on fine level
 355             virtual const scalarField& patchT
 356             (
 357                 const label patchNo
 358             ) const
 359             {
 360                 return fineFieldLevel_.patchT(patchNo);
 361             }
 362
 363             //- Return Cv
 364             virtual const scalarField& CvVar() const
 365             {
 366                 return Cv_;
 367             }
 368
 369             virtual const volScalarField& Cv() const
 370             {
 371                 return fineFieldLevel_.Cv();
 372             }
 373
 374             //- Return Cv value for patches
 375             virtual const scalarField& patchCv
 376             (
 377                 const label patchNo
 378             ) const
 379             {
 380                 return fineFieldLevel_.patchCv(patchNo);
 381             }
 382
 383             //- Return R
 384             virtual const scalarField& RVar() const
 385             {
 386                 return R_;
 387             }
 388
 389             virtual const volScalarField& R() const
 390             {
 391                 return fineFieldLevel_.R();
 392             }
 393
 394             //- Return R value for patches on fine level
 395             virtual const scalarField& patchR
 396             (
 397                 const label patchNo
 398             ) const
 399             {
 400                 return fineFieldLevel_.patchR(patchNo);
 401             }
 402
 403
 404         // Fluxes on fine level
 405
 406             virtual surfaceScalarField& rhoFlux() const
 407             {
 408                 return fineFieldLevel_.rhoFlux();
 409             }
 410
 411             virtual surfaceVectorField& rhoUFlux() const
 412             {
 413                 return fineFieldLevel_.rhoUFlux();
 414             }
 415
 416             virtual surfaceScalarField& rhoEFlux() const
 417             {
 418                 return fineFieldLevel_.rhoEFlux();
 419             }
 420
 421         // Residuals
 422
 423            //- Return rhoRes
 424             virtual const scalarField& rhoResVar() const
 425             {
 426                 return rhoRes_;
 427             }
 428
 429             virtual const volScalarField& rhoRes() const
 430             {
 431                 return fineFieldLevel_.rhoRes();
 432             }
 433
 434             //- Return rhoRes value for patches on fine level
 435             virtual const scalarField& patchRhoRes
 436             (
 437                 const label patchNo
 438             ) const
 439             {
 440                 return fineFieldLevel_.patchRhoRes(patchNo);
 441             }
 442
 443             //- Return rhoURes
 444             virtual const vectorField& rhoUResVar() const
 445             {
 446                 return rhoURes_;
 447             }
 448
 449             virtual const volVectorField& rhoURes() const
 450             {
 451                 return fineFieldLevel_.rhoURes();
 452             }
 453
 454             //- Return rhoRes value for patches on fine level
 455             virtual const vectorField& patchRhoURes
 456             (
 457                 const label patchNo
 458             ) const
 459             {
 460                 return fineFieldLevel_.patchRhoURes(patchNo);
 461             }
 462
 463             //- Return rhoERes
 464             virtual const scalarField& rhoEResVar() const
 465             {
 466                 return rhoERes_;
 467             }
 468
 469             virtual const volScalarField& rhoERes() const
 470             {
 471                 return fineFieldLevel_.rhoERes();
 472             }
 473
 474             //- Return rhoERes value for patches on fine level
 475             virtual const scalarField& patchRhoERes
 476             (
 477                 const label patchNo
 478             ) const
 479             {
 480                 return fineFieldLevel_.patchRhoERes(patchNo);
 481             }
 482
 483
 484         // Conservative variables
 485
 486             //- Return rho
 487             virtual const scalarField& rhoVar() const
 488             {
 489                 return rho_;
 490             }
 491
 492             virtual const volScalarField& rho() const
 493             {
 494                 return fineFieldLevel_.rho();
 495             }
 496
 497             //- Return rho value for patches on fine level
 498             virtual const scalarField& patchRho
 499             (
 500                 const label patchNo
 501             ) const
 502             {
 503                 return fineFieldLevel_.patchRho(patchNo);
 504             }
 505
 506             //- Return rhoU
 507             virtual const vectorField& rhoUVar() const
 508             {
 509                 return rhoU_;
 510             }
 511
 512             virtual const volVectorField& rhoU() const
 513             {
 514                 return fineFieldLevel_.rhoU();
 515             }
 516
 517             //- Return rhoU value for patches on fine level
 518             virtual const vectorField& patchRhoU
 519             (
 520                 const label patchNo
 521             ) const
 522             {
 523                 return fineFieldLevel_.patchRhoU(patchNo);
 524             }
 525
 526             //- Return rhoE
 527             virtual const scalarField& rhoEVar() const
 528             {
 529                 return rhoE_;
 530             }
 531
 532             virtual const volScalarField& rhoE() const
 533             {
 534                 return fineFieldLevel_.rhoE();
 535             }
 536
 537             //- Return rho value for patches on fine level
 538             virtual const scalarField& patchRhoE
 539             (
 540                 const label patchNo
 541             ) const
 542             {
 543                 return fineFieldLevel_.patchRhoE(patchNo);
 544             }
 545
 546             //- Access to helper data
 547             virtual const label& level() const
 548             {
 549                 return level_;
 550             }
 551 };
 552
 553
 554 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 555
 556 } // End namespace Foam
 557
 558 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 559
 560 #endif
 561
 562 // ************************************************************************* //