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

   1
   2 /*---------------------------------------------------------------------------*\
   3   =========                 |
   4   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
   5    \\    /   O peration     |
   6     \\  /    A nd           | Copyright held by original author
   7      \\/     M anipulation  |
   8 -------------------------------------------------------------------------------
   9 License
  10     This file is part of OpenFOAM.
  11
  12     OpenFOAM is free software; you can redistribute it and/or modify it
  13     under the terms of the GNU General Public License as published by the
  14     Free Software Foundation; either version 2 of the License, or (at your
  15     option) any later version.
  16
  17     OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
  18     ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  19     FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  20     for more details.
  21
  22     You should have received a copy of the GNU General Public License
  23     along with OpenFOAM; if not, write to the Free Software Foundation,
  24     Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
  25
  26 \*---------------------------------------------------------------------------*/
  27
  28 #include "limitedSurfaceInterpolationScheme.H"
  29 #include "volFields.H"
  30 #include "surfaceFields.H"
  31 #include "coupledFvPatchField.H"
  32
  33 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
  34
  35 namespace Foam
  36 {
  37
  38 // * * * * * * * * * * * * * * * * * Selectors * * * * * * * * * * * * * * * //
  39
  40 template<class Type>
  41 tmp<limitedSurfaceInterpolationScheme<Type> >
  42 limitedSurfaceInterpolationScheme<Type>::New
  43 (
  44     const fvMesh& mesh,
  45     Istream& schemeData
  46 )
  47 {
  48     if (surfaceInterpolation::debug)
  49     {
  50         Info<< "limitedSurfaceInterpolationScheme<Type>::"
  51                "New(const fvMesh&, Istream&)"
  52                " : constructing limitedSurfaceInterpolationScheme<Type>"
  53             << endl;
  54     }
  55
  56     if (schemeData.eof())
  57     {
  58         FatalIOErrorIn
  59         (
  60             "limitedSurfaceInterpolationScheme<Type>::"
  61             "New(const fvMesh&, Istream&)",
  62             schemeData
  63         )   << "Discretisation scheme not specified"
  64             << endl << endl
  65             << "Valid schemes are :" << endl
  66             << MeshConstructorTablePtr_->toc()
  67             << exit(FatalIOError);
  68     }
  69
  70     word schemeName(schemeData);
  71
  72     typename MeshConstructorTable::iterator constructorIter =
  73         MeshConstructorTablePtr_->find(schemeName);
  74
  75     if (constructorIter == MeshConstructorTablePtr_->end())
  76     {
  77         FatalIOErrorIn
  78         (
  79             "limitedSurfaceInterpolationScheme<Type>::"
  80             "New(const fvMesh&, Istream&)",
  81             schemeData
  82         )   << "Unknown discretisation scheme " << schemeName
  83             << endl << endl
  84             << "Valid schemes are :" << endl
  85             << MeshConstructorTablePtr_->toc()
  86             << exit(FatalIOError);
  87     }
  88
  89     return constructorIter()(mesh, schemeData);
  90 }
  91
  92
  93 // Return weighting factors for scheme given by name in dictionary
  94 template<class Type>
  95 tmp<limitedSurfaceInterpolationScheme<Type> >
  96 limitedSurfaceInterpolationScheme<Type>::New
  97 (
  98     const fvMesh& mesh,
  99     const surfaceScalarField& faceFlux,
 100     Istream& schemeData
 101 )
 102 {
 103     if (surfaceInterpolation::debug)
 104     {
 105         Info<< "limitedSurfaceInterpolationScheme<Type>::New"
 106                "(const fvMesh&, const surfaceScalarField&, Istream&) : "
 107                "constructing limitedSurfaceInterpolationScheme<Type>"
 108             << endl;
 109     }
 110
 111     if (schemeData.eof())
 112     {
 113         FatalIOErrorIn
 114         (
 115             "limitedSurfaceInterpolationScheme<Type>::New"
 116             "(const fvMesh&, const surfaceScalarField&, Istream&)",
 117             schemeData
 118         )   << "Discretisation scheme not specified"
 119             << endl << endl
 120             << "Valid schemes are :" << endl
 121             << MeshConstructorTablePtr_->toc()
 122             << exit(FatalIOError);
 123     }
 124
 125     word schemeName(schemeData);
 126
 127     typename MeshFluxConstructorTable::iterator constructorIter =
 128         MeshFluxConstructorTablePtr_->find(schemeName);
 129
 130     if (constructorIter == MeshFluxConstructorTablePtr_->end())
 131     {
 132         FatalIOErrorIn
 133         (
 134             "limitedSurfaceInterpolationScheme<Type>::New"
 135             "(const fvMesh&, const surfaceScalarField&, Istream&)",
 136             schemeData
 137         )   << "Unknown discretisation scheme " << schemeName
 138             << endl << endl
 139             << "Valid schemes are :" << endl
 140             << MeshFluxConstructorTablePtr_->toc()
 141             << exit(FatalIOError);
 142     }
 143
 144     return constructorIter()(mesh, faceFlux, schemeData);
 145 }
 146
 147
 148 // * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
 149
 150 template<class Type>
 151 limitedSurfaceInterpolationScheme<Type>::~limitedSurfaceInterpolationScheme()
 152 {}
 153
 154
 155 // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
 156
 157 template<class Type>
 158 tmp<surfaceScalarField> limitedSurfaceInterpolationScheme<Type>::weights
 159 (
 160     const GeometricField<Type, fvPatchField, volMesh>& phi,
 161     const surfaceScalarField& CDweights,
 162     tmp<surfaceScalarField> tLimiter
 163 ) const
 164 {
 165     // Note that here the weights field is initialised as the limiter
 166     // from which the weight is calculated using the limiter value
 167     surfaceScalarField& Weights = tLimiter();
 168
 169     scalarField& pWeights = Weights.internalField();
 170
 171     forAll(pWeights, face)
 172     {
 173         pWeights[face] =
 174             pWeights[face]*CDweights[face]
 175           + (1.0 - pWeights[face])*pos(faceFlux_[face]);
 176     }
 177
 178     surfaceScalarField::GeometricBoundaryField& bWeights =
 179         Weights.boundaryField();
 180
 181     forAll(bWeights, patchI)
 182     {
 183         scalarField& pWeights = bWeights[patchI];
 184
 185         const scalarField& pCDweights = CDweights.boundaryField()[patchI];
 186         const scalarField& pFaceFlux = faceFlux_.boundaryField()[patchI];
 187
 188         forAll(pWeights, face)
 189         {
 190             pWeights[face] =
 191                 pWeights[face]*pCDweights[face]
 192               + (1.0 - pWeights[face])*pos(pFaceFlux[face]);
 193         }
 194     }
 195
 196     return tLimiter;
 197 }
 198
 199 template<class Type>
 200 tmp<surfaceScalarField> limitedSurfaceInterpolationScheme<Type>::weights
 201 (
 202     const GeometricField<Type, fvPatchField, volMesh>& phi
 203 ) const
 204 {
 205     return this->weights
 206     (
 207         phi,
 208         this->mesh().surfaceInterpolation::weights(),
 209         this->limiter(phi)
 210     );
 211 }
 212
 213 template<class Type>
 214 tmp<GeometricField<Type, fvsPatchField, surfaceMesh> >
 215 limitedSurfaceInterpolationScheme<Type>::flux
 216 (
 217     const GeometricField<Type, fvPatchField, volMesh>& phi
 218 ) const
 219 {
 220     return faceFlux_*interpolate(phi);
 221 }
 222
 223
 224 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 225
 226 } // End namespace Foam
 227
 228 // ************************************************************************* //