src/finiteVolume/interpolation/surfaceInterpolation/limitedSchemes/linearUpwindV/linearUpwindV.H

   1 /*---------------------------------------------------------------------------*\
   2   =========                 |
   3   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
   4    \\    /   O peration     |
   5     \\  /    A nd           | Copyright (C) 1991-2008 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 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     Foam::linearUpwindV
  27
  28 Description
  29     linearUpwindV interpolation scheme class derived from upwind and returns
  30     upwind weighting factors but also applies an explicit correction.
  31
  32 SourceFiles
  33     linearUpwindV.C
  34
  35 \*---------------------------------------------------------------------------*/
  36
  37 #ifndef linearUpwindV_H
  38 #define linearUpwindV_H
  39
  40 #include "upwind.H"
  41 #include "gaussGrad.H"
  42
  43 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
  44
  45 namespace Foam
  46 {
  47
  48 /*---------------------------------------------------------------------------*\
  49                            Class linearUpwindV Declaration
  50 \*---------------------------------------------------------------------------*/
  51
  52 template<class Type>
  53 class linearUpwindV
  54 :
  55     public upwind<Type>
  56 {
  57     // Private Data
  58
  59         tmp<fv::gradScheme<Type> > gradScheme_;
  60
  61
  62     // Private Member Functions
  63
  64         //- Disallow default bitwise copy construct
  65         linearUpwindV(const linearUpwindV&);
  66
  67         //- Disallow default bitwise assignment
  68         void operator=(const linearUpwindV&);
  69
  70
  71 public:
  72
  73     //- Runtime type information
  74     TypeName("linearUpwindV");
  75
  76
  77     // Constructors
  78
  79         //- Construct from faceFlux
  80         linearUpwindV
  81         (
  82             const fvMesh& mesh,
  83             const surfaceScalarField& faceFlux
  84         )
  85         :
  86             upwind<Type>(mesh, faceFlux),
  87             gradScheme_
  88             (
  89                 new fv::gaussGrad<Type>(mesh)
  90             )
  91         {}
  92
  93         //- Construct from Istream.
  94         //  The name of the flux field is read from the Istream and looked-up
  95         //  from the mesh objectRegistry
  96         linearUpwindV
  97         (
  98             const fvMesh& mesh,
  99             Istream& schemeData
 100         )
 101         :
 102             upwind<Type>(mesh, schemeData),
 103             gradScheme_
 104             (
 105                 fv::gradScheme<Type>::New
 106                 (
 107                     mesh,
 108                     schemeData
 109                 )
 110             )
 111         {}
 112
 113         //- Construct from faceFlux and Istream
 114         linearUpwindV
 115         (
 116             const fvMesh& mesh,
 117             const surfaceScalarField& faceFlux,
 118             Istream& schemeData
 119         )
 120         :
 121             upwind<Type>(mesh, faceFlux, schemeData),
 122             gradScheme_
 123             (
 124                 fv::gradScheme<Type>::New
 125                 (
 126                     mesh,
 127                     schemeData
 128                 )
 129             )
 130         {}
 131
 132
 133     // Member Functions
 134
 135         //- Return true if this scheme uses an explicit correction
 136         virtual bool corrected() const
 137         {
 138             return true;
 139         }
 140
 141         //- Return the explicit correction to the face-interpolate
 142         virtual tmp<GeometricField<Type, fvsPatchField, surfaceMesh> >
 143         correction
 144         (
 145             const GeometricField<Type, fvPatchField, volMesh>& vf
 146         ) const
 147         {
 148             const fvMesh& mesh = this->mesh();
 149
 150             tmp<GeometricField<Type, fvsPatchField, surfaceMesh> > tsfCorr
 151             (
 152                 new GeometricField<Type, fvsPatchField, surfaceMesh>
 153                 (
 154                     IOobject
 155                     (
 156                         vf.name(),
 157                         mesh.time().timeName(),
 158                         mesh
 159                     ),
 160                     mesh,
 161                     dimensioned<Type>
 162                     (
 163                         vf.name(),
 164                         vf.dimensions(),
 165                         pTraits<Type>::zero
 166                     )
 167                 )
 168             );
 169
 170             GeometricField<Type, fvsPatchField, surfaceMesh>& sfCorr = tsfCorr();
 171
 172             const surfaceScalarField& faceFlux = this->faceFlux_;
 173             const surfaceScalarField& w = mesh.weights();
 174
 175             const labelList& own = mesh.owner();
 176             const labelList& nei = mesh.neighbour();
 177
 178             const vectorField& C = mesh.C();
 179             const vectorField& Cf = mesh.Cf();
 180
 181             GeometricField
 182             <typename outerProduct<vector, Type>::type, fvPatchField, volMesh>
 183                 gradVf = gradScheme_().grad(vf);
 184
 185             forAll(faceFlux, facei)
 186             {
 187                 vector maxCorr;
 188
 189                 if (faceFlux[facei] > 0.0)
 190                 {
 191                     maxCorr =
 192                         (1.0 - w[facei])
 193                        *(vf[nei[facei]] - vf[own[facei]]);
 194
 195                     sfCorr[facei] =
 196                         (Cf[facei] - C[own[facei]]) & gradVf[own[facei]];
 197                 }
 198                 else
 199                 {
 200                     maxCorr =
 201                         w[facei]*(vf[own[facei]] - vf[nei[facei]]);
 202
 203                     sfCorr[facei] =
 204                         (Cf[facei] - C[nei[facei]]) & gradVf[nei[facei]];
 205                 }
 206
 207                 scalar sfCorrs = magSqr(sfCorr[facei]);
 208                 scalar maxCorrs = sfCorr[facei] & maxCorr;
 209
 210                 if (sfCorrs > 0)
 211                 {
 212                     if (maxCorrs < 0)
 213                     {
 214                         sfCorr[facei] = vector::zero;
 215                     }
 216                     else if (sfCorrs > maxCorrs)
 217                     {
 218                         sfCorr[facei] *= maxCorrs/(sfCorrs + VSMALL);
 219                     }
 220                 }
 221                 else if (sfCorrs < 0)
 222                 {
 223                     if (maxCorrs > 0)
 224                     {
 225                         sfCorr[facei] = vector::zero;
 226                     }
 227                     else if (sfCorrs < maxCorrs)
 228                     {
 229                         sfCorr[facei] *= maxCorrs/(sfCorrs - VSMALL);
 230                     }
 231                 }
 232             }
 233
 234             return tsfCorr;
 235         }
 236 };
 237
 238
 239 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 240
 241 } // End namespace Foam
 242
 243 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 244
 245 #endif
 246
 247 // ************************************************************************* //