src/finiteVolume/interpolation/surfaceInterpolation/schemes/cubic/cubic.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::cubic
  27
  28 Description
  29     Cubic interpolation scheme class derived from linear and returns
  30     linear weighting factors but also applies an explicit correction.
  31
  32 SourceFiles
  33     cubic.C
  34
  35 \*---------------------------------------------------------------------------*/
  36
  37 #ifndef cubic_H
  38 #define cubic_H
  39
  40 #include "linear.H"
  41 #include "gaussGrad.H"
  42
  43 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
  44
  45 namespace Foam
  46 {
  47
  48 /*---------------------------------------------------------------------------*\
  49                            Class cubic Declaration
  50 \*---------------------------------------------------------------------------*/
  51
  52 template<class Type>
  53 class cubic
  54 :
  55     public linear<Type>
  56 {
  57     // Private Member Functions
  58
  59         //- Disallow default bitwise copy construct
  60         cubic(const cubic&);
  61
  62         //- Disallow default bitwise assignment
  63         void operator=(const cubic&);
  64
  65
  66 public:
  67
  68     //- Runtime type information
  69     TypeName("cubic");
  70
  71
  72     // Constructors
  73
  74         //- Construct from mesh
  75         cubic(const fvMesh& mesh)
  76         :
  77             linear<Type>(mesh)
  78         {}
  79
  80         //- Construct from mesh and Istream
  81         cubic
  82         (
  83             const fvMesh& mesh,
  84             Istream&
  85         )
  86         :
  87             linear<Type>(mesh)
  88         {}
  89
  90         //- Construct from mesh, faceFlux and Istream
  91         cubic
  92         (
  93             const fvMesh& mesh,
  94             const surfaceScalarField&,
  95             Istream&
  96         )
  97         :
  98             linear<Type>(mesh)
  99         {}
 100
 101
 102     // Member Functions
 103
 104         //- Return true if this scheme uses an explicit correction
 105         virtual bool corrected() const
 106         {
 107             return true;
 108         }
 109
 110         //- Return the explicit correction to the face-interpolate
 111         virtual tmp<GeometricField<Type, fvsPatchField, surfaceMesh> >
 112         correction
 113         (
 114             const GeometricField<Type, fvPatchField, volMesh>& vf
 115         ) const
 116         {
 117             const fvMesh& mesh = this->mesh();
 118
 119             // calculate the appropriate interpolation factors
 120             const surfaceScalarField& lambda = mesh.weights();
 121
 122             surfaceScalarField kSc =
 123                 lambda*(scalar(1) - lambda*(scalar(3) - scalar(2)*lambda));
 124
 125             surfaceScalarField kVecP = sqr(scalar(1) - lambda)*lambda;
 126             surfaceScalarField kVecN = sqr(lambda)*(lambda - scalar(1));
 127
 128             tmp<GeometricField<Type, fvsPatchField, surfaceMesh> > tsfCorr
 129             (
 130                 new GeometricField<Type, fvsPatchField, surfaceMesh>
 131                 (
 132                     IOobject
 133                     (
 134                         vf.name(),
 135                         mesh.time().timeName(),
 136                         mesh
 137                     ),
 138                     surfaceInterpolationScheme<Type>::interpolate(vf, kSc, -kSc)
 139                 )
 140             );
 141
 142             GeometricField<Type, fvsPatchField, surfaceMesh>& sfCorr = tsfCorr();
 143
 144             for (direction cmpt=0; cmpt<pTraits<Type>::nComponents; cmpt++)
 145             {
 146                 sfCorr.replace
 147                 (
 148                     cmpt,
 149                     sfCorr.component(cmpt)
 150                   + (
 151                         surfaceInterpolationScheme
 152                         <
 153                             typename outerProduct
 154                             <
 155                                 vector,
 156                                 typename pTraits<Type>::cmptType
 157                             >::type
 158                         >::interpolate
 159                         (
 160                             fv::gaussGrad
 161                             <typename pTraits<Type>::cmptType>(mesh)
 162                            .grad(vf.component(cmpt)),
 163                             kVecP,
 164                             kVecN
 165                         ) & mesh.Sf()
 166                     )/mesh.magSf()/mesh.surfaceInterpolation::deltaCoeffs()
 167                 );
 168             }
 169
 170             forAll (sfCorr.boundaryField(), pi)
 171             {
 172                 if (!sfCorr.boundaryField()[pi].coupled())
 173                 {
 174                     sfCorr.boundaryField()[pi] = pTraits<Type>::zero;
 175                 }
 176             }
 177
 178             return tsfCorr;
 179         }
 180 };
 181
 182
 183 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 184
 185 } // End namespace Foam
 186
 187 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 188
 189 #endif
 190
 191 // ************************************************************************* //