src/dbns/numericFlux/numericFlux.H

   1 /*---------------------------------------------------------------------------*\
   2   =========                 |
   3   \\      /  F ield         | foam-extend: Open Source CFD
   4    \\    /   O peration     |
   5     \\  /    A nd           | For copyright notice see file Copyright
   6      \\/     M anipulation  |
   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     numericFlux
  26
  27 Description
  28     Single level numeric flux class for density-based solvers
  29
  30 Author
  31     Aleksandar Jemcov
  32     Rewrite by Hrvoje Jasak
  33
  34 SourceFiles
  35     numericFlux.H
  36     numericFlux.C
  37
  38 \*---------------------------------------------------------------------------*/
  39
  40 #ifndef numericFlux_H
  41 #define numericFlux_H
  42
  43 #include "numericFluxBase.H"
  44 #include "basicThermo.H"
  45
  46 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
  47
  48 namespace Foam
  49 {
  50
  51 /*---------------------------------------------------------------------------*\
  52                           Class numericFlux Declaration
  53 \*---------------------------------------------------------------------------*/
  54
  55 template<class Flux, class Limiter>
  56 class numericFlux
  57 :
  58     public numericFluxBase<Flux>
  59 {
  60     // Private data
  61
  62         //- Reference to mesh
  63         const fvMesh& mesh_;
  64
  65
  66         // Reference to primitive fields
  67
  68             //- Static pressure
  69             const volScalarField& p_;
  70
  71             //- Velocity
  72             const volVectorField& U_;
  73
  74             //- Static temperature
  75             const volScalarField& T_;
  76
  77             //- Reference to the thermophysicalModel
  78             basicThermo& thermo_;
  79
  80
  81         // Fluxes
  82
  83             //- Density flux
  84             surfaceScalarField rhoFlux_;
  85
  86             //- Velocity flux
  87             surfaceVectorField rhoUFlux_;
  88
  89             //- Energy flux
  90             surfaceScalarField rhoEFlux_;
  91
  92
  93         // Gradients
  94
  95             //- Static pressure gradient
  96             volVectorField gradP_;
  97
  98             //- Velocity gradient
  99             volTensorField gradU_;
 100
 101             //- Static temperature gradient
 102             volVectorField gradT_;
 103
 104
 105     // Private Member Functions
 106
 107         //- Disallow default bitwise copy construct
 108         numericFlux(const numericFlux&);
 109
 110         //- Disallow default bitwise assignment
 111         void operator=(const numericFlux&);
 112
 113
 114         //- Return internal field of mass flux
 115         const scalarField& rhoFluxI() const
 116         {
 117             return rhoFlux_.internalField();
 118         }
 119
 120         //- Return access to internal field of mass flux
 121         scalarField& rhoFluxI()
 122         {
 123             return rhoFlux_.internalField();
 124         }
 125
 126         //- Return internal field of momentum flux
 127         const vectorField& rhoUFluxI() const
 128         {
 129             return rhoUFlux_.internalField();
 130         }
 131
 132         //- Return access to internal field of momentum flux
 133         vectorField& rhoUFluxI()
 134         {
 135             return rhoUFlux_.internalField();
 136         }
 137
 138          //- Return access to internal field of energy flux
 139         const scalarField& rhoEFluxI() const
 140         {
 141             return rhoEFlux_.internalField();
 142         }
 143
 144         //- Return access to internal field of energy flux
 145         scalarField& rhoEFluxI()
 146         {
 147             return rhoEFlux_.internalField();
 148         }
 149
 150
 151 public:
 152
 153     // Constructors
 154
 155         //- Construct from components
 156         numericFlux
 157         (
 158             const volScalarField& p,
 159             const volVectorField& U,
 160             const volScalarField& T,
 161             basicThermo& thermo
 162         );
 163
 164
 165     //- Destructor
 166     virtual ~numericFlux()
 167     {}
 168
 169
 170     // Member Functions
 171
 172         //- Return mesh reference
 173         const fvMesh& mesh() const
 174         {
 175             return mesh_;
 176         }
 177
 178
 179         // Return fluxes
 180
 181             //- Return density flux
 182             virtual const surfaceScalarField& rhoFlux() const
 183             {
 184                 return rhoFlux_;
 185             }
 186
 187             //- Return velocity flux
 188             virtual const surfaceVectorField& rhoUFlux() const
 189             {
 190                 return rhoUFlux_;
 191             }
 192
 193             //- Return energy flux
 194             virtual const surfaceScalarField& rhoEFlux() const
 195             {
 196                 return rhoEFlux_;
 197             }
 198
 199
 200        // Return residuals
 201
 202             //- Return density equation residual
 203             virtual tmp<scalarField> rhoResidual() const
 204             {
 205                 return fvc::div(rhoFlux_)().internalField();
 206             }
 207
 208             //- Return momentum equation flux
 209             virtual tmp<vectorField> rhoUResidual() const
 210             {
 211                 return fvc::div(rhoUFlux_)().internalField();
 212             }
 213
 214             //- Return energy equation flux
 215             virtual tmp<scalarField> rhoEResidual() const
 216             {
 217                 return fvc::div(rhoEFlux_)().internalField();
 218             }
 219
 220
 221         // Return Gradients
 222
 223             //- Return pressure gradient
 224             const volVectorField& gradP() const
 225             {
 226                 return gradP_;
 227             }
 228
 229             //- Return pressure gradient
 230             const volTensorField& gradU() const
 231             {
 232                 return gradU_;
 233             }
 234
 235             //- Return Temperature gradient
 236             const volVectorField& gradT() const
 237             {
 238                 return gradT_;
 239             }
 240
 241
 242         // Update fluxes based on current state
 243
 244             //- Compute flux
 245             virtual void computeFlux();
 246 };
 247
 248
 249 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 250
 251 } // End namespace Foam
 252
 253 #ifdef NoRepository
 254 #   include "numericFlux.C"
 255 #endif
 256
 257 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 258
 259 #endif
 260
 261 // ************************************************************************* //