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

   1 /*---------------------------------------------------------------------------*\
   2   =========                 |
   3   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
   4    \\    /   O peration     |
   5     \\  /    A nd           | Copyright held by original author
   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::limitedSurfaceInterpolationScheme
  27
  28 Description
  29     Abstract base class for limited surface interpolation schemes.
  30
  31 SourceFiles
  32     limitedSurfaceInterpolationScheme.C
  33
  34 \*---------------------------------------------------------------------------*/
  35
  36 #ifndef limitedSurfaceInterpolationScheme_H
  37 #define limitedSurfaceInterpolationScheme_H
  38
  39 #include "surfaceInterpolationScheme.H"
  40
  41 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
  42
  43 namespace Foam
  44 {
  45
  46 /*---------------------------------------------------------------------------*\
  47                  Class limitedSurfaceInterpolationScheme Declaration
  48 \*---------------------------------------------------------------------------*/
  49
  50 template<class Type>
  51 class limitedSurfaceInterpolationScheme
  52 :
  53     public surfaceInterpolationScheme<Type>
  54 {
  55     // Private Member Functions
  56
  57         //- Disallow copy construct
  58         limitedSurfaceInterpolationScheme
  59         (
  60             const limitedSurfaceInterpolationScheme&
  61         );
  62
  63         //- Disallow default bitwise assignment
  64         void operator=(const limitedSurfaceInterpolationScheme&);
  65
  66
  67 protected:
  68
  69     // Protected data
  70
  71         const surfaceScalarField& faceFlux_;
  72
  73
  74 public:
  75
  76     //- Runtime type information
  77     TypeName("limitedSurfaceInterpolationScheme");
  78
  79
  80     // Declare run-time constructor selection tables
  81
  82         declareRunTimeSelectionTable
  83         (
  84             tmp,
  85             limitedSurfaceInterpolationScheme,
  86             Mesh,
  87             (
  88                 const fvMesh& mesh,
  89                 Istream& schemeData
  90             ),
  91             (mesh, schemeData)
  92         );
  93
  94         declareRunTimeSelectionTable
  95         (
  96             tmp,
  97             limitedSurfaceInterpolationScheme,
  98             MeshFlux,
  99             (
 100                 const fvMesh& mesh,
 101                 const surfaceScalarField& faceFlux,
 102                 Istream& schemeData
 103             ),
 104             (mesh, faceFlux, schemeData)
 105         );
 106
 107
 108     // Constructors
 109
 110         //- Construct from mesh and faceFlux
 111         limitedSurfaceInterpolationScheme
 112         (
 113             const fvMesh& mesh,
 114             const surfaceScalarField& faceFlux
 115         )
 116         :
 117             surfaceInterpolationScheme<Type>(mesh),
 118             faceFlux_(faceFlux)
 119         {}
 120
 121
 122         //- Construct from mesh and Istream.
 123         //  The name of the flux field is read from the Istream and looked-up
 124         //  from the mesh objectRegistry
 125         limitedSurfaceInterpolationScheme
 126         (
 127             const fvMesh& mesh,
 128             Istream& is
 129         )
 130         :
 131             surfaceInterpolationScheme<Type>(mesh),
 132             faceFlux_
 133             (
 134                 mesh.lookupObject<surfaceScalarField>
 135                 (
 136                     word(is)
 137                 )
 138             )
 139         {}
 140
 141
 142     // Selectors
 143
 144         //- Return new tmp interpolation scheme
 145         static tmp<limitedSurfaceInterpolationScheme<Type> > New
 146         (
 147             const fvMesh& mesh,
 148             Istream& schemeData
 149         );
 150
 151         //- Return new tmp interpolation scheme
 152         static tmp<limitedSurfaceInterpolationScheme<Type> > New
 153         (
 154             const fvMesh& mesh,
 155             const surfaceScalarField& faceFlux,
 156             Istream& schemeData
 157         );
 158
 159
 160     // Destructor
 161
 162         virtual ~limitedSurfaceInterpolationScheme();
 163
 164
 165     // Member Functions
 166
 167         //- Return the interpolation weighting factors
 168         virtual tmp<surfaceScalarField> limiter
 169         (
 170             const GeometricField<Type, fvPatchField, volMesh>&
 171         ) const = 0;
 172
 173         //- Return the interpolation weighting factors for the given field,
 174         //  by limiting the given weights with the given limiter
 175         tmp<surfaceScalarField> weights
 176         (
 177             const GeometricField<Type, fvPatchField, volMesh>&,
 178             const surfaceScalarField& CDweights,
 179             tmp<surfaceScalarField> tLimiter
 180         ) const;
 181
 182         //- Return the interpolation weighting factors for the given field
 183         virtual tmp<surfaceScalarField> weights
 184         (
 185             const GeometricField<Type, fvPatchField, volMesh>&
 186         ) const;
 187
 188         //- Return the flux consistent with interpolation
 189         virtual tmp<GeometricField<Type, fvsPatchField, surfaceMesh> >
 190         flux
 191         (
 192             const GeometricField<Type, fvPatchField, volMesh>&
 193         ) const;
 194 };
 195
 196
 197 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 198
 199 } // End namespace Foam
 200
 201 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 202
 203 // Add the patch constructor functions to the hash tables
 204
 205 #define makelimitedSurfaceInterpolationTypeScheme(SS, Type)                   \
 206                                                                               \
 207 defineNamedTemplateTypeNameAndDebug(SS<Type>, 0);                             \
 208                                                                               \
 209 surfaceInterpolationScheme<Type>::addMeshConstructorToTable<SS<Type> >        \
 210     add##SS##Type##MeshConstructorToTable_;                                   \
 211                                                                               \
 212 surfaceInterpolationScheme<Type>::addMeshFluxConstructorToTable<SS<Type> >    \
 213     add##SS##Type##MeshFluxConstructorToTable_;                               \
 214                                                                               \
 215 limitedSurfaceInterpolationScheme<Type>::addMeshConstructorToTable<SS<Type> > \
 216     add##SS##Type##MeshConstructorToLimitedTable_;                            \
 217                                                                               \
 218 limitedSurfaceInterpolationScheme<Type>::addMeshFluxConstructorToTable<SS<Type> >\
 219     add##SS##Type##MeshFluxConstructorToLimitedTable_;
 220
 221 #define makelimitedSurfaceInterpolationScheme(SS)                             \
 222                                                                               \
 223 makelimitedSurfaceInterpolationTypeScheme(SS, scalar)                         \
 224 makelimitedSurfaceInterpolationTypeScheme(SS, vector)                         \
 225 makelimitedSurfaceInterpolationTypeScheme(SS, sphericalTensor)                \
 226 makelimitedSurfaceInterpolationTypeScheme(SS, symmTensor)                     \
 227 makelimitedSurfaceInterpolationTypeScheme(SS, tensor)
 228
 229
 230 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 231
 232 #ifdef NoRepository
 233 #   include "limitedSurfaceInterpolationScheme.C"
 234 #endif
 235
 236 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 237
 238 #endif
 239
 240 // ************************************************************************* //