src/finiteVolume/cfdTools/general/porousMedia/porousZone.H

   1 /*---------------------------------------------------------------------------*\
   2   =========                 |
   3   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
   4    \\    /   O peration     |
   5     \\  /    A nd           | Copyright (C) 2004-2011 OpenCFD Ltd.
   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
  13     the Free Software Foundation, either version 3 of the License, or
  14     (at your 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, see <http://www.gnu.org/licenses/>.
  23
  24 Namespace
  25     Foam::porousMedia
  26
  27 Description
  28     Namespace for models related to porous media
  29
  30 Class
  31     Foam::porousZone
  32
  33 Description
  34     Porous zone definition based on cell zones.
  35
  36     Porous zone definition based on cell zones and parameters obtained from a
  37     control dictionary constructed from the given stream. The orientation of
  38     the porous region is defined with the same notation as a coordinateSystem,
  39     but only a Cartesian coordinate system is valid.
  40
  41     Implemented porosity models:
  42
  43     powerLaw (\e C0 and \e C1 parameters)
  44     \f[
  45         S = - \rho C_0 |U|^{(C_1 - 1)/2} U
  46     \f]
  47
  48     Darcy-Forchheimer (@e d and \e f parameters)
  49     \f[
  50         S = - (\mu \, d + \frac{\rho |U|}{2} \, f) U
  51     \f]
  52
  53
  54     Since negative Darcy/Forchheimer parameters are invalid, they can be used
  55     to specify a multiplier (of the max component).
  56
  57     The porousZones method porousZones::ddt() mirrors the normal fvm::ddt()
  58     method, but accounts for the effective volume of the cells.
  59
  60     An example dictionary entry:
  61     \verbatim
  62     cat1
  63     {
  64         note            "some catalyst";
  65         coordinateSystem    system_10;
  66         porosity        0.809;
  67         intensity       0.001;      // optional
  68         mixingLength    0.0001;     // optional
  69         printCoeffs     yes;        // optional: feedback for the user
  70
  71         Darcy
  72         {
  73             d   d [0 -2 0 0 0]  (-1000 -1000 5.3756e+07);
  74             f   f [0 -1 0 0 0]  (-1000 -1000 15.83);
  75         }
  76     }
  77     \endverbatim
  78
  79 See Also
  80     porousZones and coordinateSystems
  81
  82 SourceFiles
  83     porousZone.C
  84     porousZoneTemplates.C
  85
  86 \*---------------------------------------------------------------------------*/
  87
  88 #ifndef porousZone_H
  89 #define porousZone_H
  90
  91 #include "dictionary.H"
  92 #include "coordinateSystem.H"
  93 #include "coordinateSystems.H"
  94 #include "wordList.H"
  95 #include "labelList.H"
  96 #include "dimensionedScalar.H"
  97 #include "dimensionedTensor.H"
  98 #include "primitiveFieldsFwd.H"
  99 #include "volFieldsFwd.H"
 100 #include "fvMatricesFwd.H"
 101
 102 #include "fvMesh.H"
 103
 104 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 105
 106 namespace Foam
 107 {
 108
 109 class fvMesh;
 110
 111 /*---------------------------------------------------------------------------*\
 112                         Class porousZone Declaration
 113 \*---------------------------------------------------------------------------*/
 114
 115 class porousZone
 116 {
 117     // Private data
 118
 119         //- Name of this zone, or a regular expression
 120         keyType key_;
 121
 122         //- Reference to the finite volume mesh this zone is part of
 123         const fvMesh& mesh_;
 124
 125         //- Dictionary containing the parameters
 126         dictionary dict_;
 127
 128         //- Cell zone Ids
 129         labelList cellZoneIds_;
 130
 131         //- Coordinate system used for the zone (Cartesian)
 132         coordinateSystem coordSys_;
 133
 134         //- porosity of the zone (0 < porosity <= 1)
 135         //  Placeholder for treatment of temporal terms.
 136         //  Currently unused.
 137         scalar porosity_;
 138
 139         //- Turbulent intensity as fraction of the velocity
 140         scalar intensity_;
 141
 142         //- Turbulent length scale
 143         scalar mixingLength_;
 144
 145         //- powerLaw coefficient C0
 146         scalar C0_;
 147
 148         //- powerLaw coefficient C1
 149         scalar C1_;
 150
 151         //- Darcy coefficient
 152         dimensionedTensor D_;
 153
 154         //- Forchheimer coefficient
 155         dimensionedTensor F_;
 156
 157
 158     // Private Member Functions
 159
 160         //- adjust negative resistance values to be multiplier of max value
 161         static void adjustNegativeResistance(dimensionedVector& resist);
 162
 163         //- Power-law resistance
 164         template<class RhoFieldType>
 165         void addPowerLawResistance
 166         (
 167             scalarField& Udiag,
 168             const scalarField& V,
 169             const RhoFieldType& rho,
 170             const vectorField& U
 171         ) const;
 172
 173         //- Viscous and inertial resistance
 174         template<class RhoFieldType>
 175         void addViscousInertialResistance
 176         (
 177             scalarField& Udiag,
 178             vectorField& Usource,
 179             const scalarField& V,
 180             const RhoFieldType& rho,
 181             const scalarField& mu,
 182             const vectorField& U
 183         ) const;
 184
 185
 186         //- Power-law resistance
 187         template<class RhoFieldType>
 188         void addPowerLawResistance
 189         (
 190             tensorField& AU,
 191             const RhoFieldType& rho,
 192             const vectorField& U
 193         ) const;
 194
 195         //- Viscous and inertial resistance
 196         template<class RhoFieldType>
 197         void addViscousInertialResistance
 198         (
 199             tensorField& AU,
 200             const RhoFieldType& rho,
 201             const scalarField& mu,
 202             const vectorField& U
 203         ) const;
 204
 205
 206         //- Disallow default bitwise copy construct
 207         porousZone(const porousZone&);
 208
 209         //- Disallow default bitwise assignment
 210         void operator=(const porousZone&);
 211
 212
 213 public:
 214
 215     // Constructors
 216
 217         //- Construct from components
 218         porousZone(const keyType& key, const fvMesh&, const dictionary&);
 219
 220         //- Return clone
 221         autoPtr<porousZone> clone() const
 222         {
 223             notImplemented("autoPtr<porousZone> clone() const");
 224             return autoPtr<porousZone>(NULL);
 225         }
 226
 227         //- Return pointer to new porousZone created on freestore from Istream
 228         class iNew
 229         {
 230             //- Reference to the finite volume mesh this zone is part of
 231             const fvMesh& mesh_;
 232
 233         public:
 234
 235             iNew(const fvMesh& mesh)
 236             :
 237                 mesh_(mesh)
 238             {}
 239
 240             autoPtr<porousZone> operator()(Istream& is) const
 241             {
 242                 keyType key(is);
 243                 dictionary dict(is);
 244
 245                 return autoPtr<porousZone>(new porousZone(key, mesh_, dict));
 246             }
 247         };
 248
 249
 250     //- Destructor
 251     virtual ~porousZone()
 252     {}
 253
 254
 255     // Member Functions
 256
 257         // Access
 258
 259             //- cellZone name
 260             const keyType& zoneName() const
 261             {
 262                 return key_;
 263             }
 264
 265             //- Return mesh
 266             const fvMesh& mesh() const
 267             {
 268                 return mesh_;
 269             }
 270
 271             //- cellZone numbers
 272             const labelList& zoneIds() const
 273             {
 274                 return cellZoneIds_;
 275             }
 276
 277             //- dictionary values used for the porousZone
 278             const dictionary& dict() const
 279             {
 280                 return dict_;
 281             }
 282
 283             //- Return coordinate system
 284             const coordinateSystem& coordSys() const
 285             {
 286                 return coordSys_;
 287             }
 288
 289             //- Return origin
 290             const point& origin() const
 291             {
 292                 return coordSys_.origin();
 293             }
 294
 295             //- Return axis
 296             vector axis() const
 297             {
 298                 return coordSys_.axis();
 299             }
 300
 301             //- Return porosity
 302             scalar porosity() const
 303             {
 304                 return porosity_;
 305             }
 306
 307             //- Edit access to porosity
 308             scalar& porosity()
 309             {
 310                 return porosity_;
 311             }
 312
 313             //- Return turbulent intensity
 314             scalar intensity() const
 315             {
 316                 return intensity_;
 317             }
 318
 319             //- Edit access to turbulent intensity
 320             scalar& intensity()
 321             {
 322                 return intensity_;
 323             }
 324
 325             //- Return turbulent length scale
 326             scalar mixingLength() const
 327             {
 328                 return mixingLength_;
 329             }
 330
 331             //- Edit access to turbulent length scale
 332             scalar& mixingLength()
 333             {
 334                 return mixingLength_;
 335             }
 336
 337
 338         //- Modify time derivative elements according to porosity
 339         template<class Type>
 340         void modifyDdt(fvMatrix<Type>&) const;
 341
 342         //- Add the viscous and inertial resistance force contribution
 343         //  to the momentum equation
 344         void addResistance(fvVectorMatrix& UEqn) const;
 345
 346         //- Add the viscous and inertial resistance force contribution
 347         //  to the tensorial diagonal.
 348         //  Optionally correct the processor BCs of AU.
 349         void addResistance
 350         (
 351             const fvVectorMatrix& UEqn,
 352             volTensorField& AU,
 353             bool correctAUprocBC = true
 354         ) const;
 355
 356         //- Write the porousZone dictionary
 357         virtual void writeDict(Ostream&, bool subDict = true) const;
 358
 359
 360     // Ostream Operator
 361
 362         friend Ostream& operator<<(Ostream&, const porousZone&);
 363 };
 364
 365
 366 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 367
 368 } // End namespace Foam
 369
 370 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 371
 372 #ifdef NoRepository
 373 #   include "porousZoneTemplates.C"
 374 #endif
 375
 376 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 377
 378 #endif
 379
 380 // ************************************************************************* //