src/finiteArea/interpolation/edgeInterpolation/edgeInterpolate.C

   1 /*---------------------------------------------------------------------------*\
   2   =========                 |
   3   \\      /  F ield         | foam-extend: Open Source CFD
   4    \\    /   O peration     | Version:     3.2
   5     \\  /    A nd           | Web:         http://www.foam-extend.org
   6      \\/     M anipulation  | For copyright notice see file Copyright
   7 -------------------------------------------------------------------------------
   8 License
   9     This file is part of foam-extend.
  10
  11     foam-extend 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 3 of the License, or (at your
  14     option) any later version.
  15
  16     foam-extend is distributed in the hope that it will be useful, but
  17     WITHOUT ANY WARRANTY; without even the implied warranty of
  18     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  19     General Public License for more details.
  20
  21     You should have received a copy of the GNU General Public License
  22     along with foam-extend.  If not, see <http://www.gnu.org/licenses/>.
  23
  24 Description
  25
  26 \*---------------------------------------------------------------------------*/
  27
  28 #include "edgeInterpolate.H"
  29
  30 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
  31
  32 namespace Foam
  33 {
  34
  35 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
  36
  37 namespace fac
  38 {
  39
  40 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
  41
  42 // Return weighting factors for scheme given by name in dictionary
  43 template<class Type>
  44 tmp<edgeInterpolationScheme<Type> > scheme
  45 (
  46     const edgeScalarField& faceFlux,
  47     Istream& streamData
  48 )
  49 {
  50     return edgeInterpolationScheme<Type>::New
  51     (
  52         faceFlux.mesh(),
  53         faceFlux,
  54         streamData
  55     );
  56 }
  57
  58
  59 // Return weighting factors for scheme given by name in dictionary
  60 template<class Type>
  61 tmp<edgeInterpolationScheme<Type> > scheme
  62 (
  63     const edgeScalarField& faceFlux,
  64     const word& name
  65 )
  66 {
  67     return edgeInterpolationScheme<Type>::New
  68     (
  69         faceFlux.mesh(),
  70         faceFlux,
  71         faceFlux.mesh().schemesDict().interpolationScheme(name)
  72     );
  73 }
  74
  75
  76 // Return weighting factors for scheme given by name in dictionary
  77 template<class Type>
  78 tmp<edgeInterpolationScheme<Type> > scheme
  79 (
  80     const faMesh& mesh,
  81     Istream& streamData
  82 )
  83 {
  84     return edgeInterpolationScheme<Type>::New
  85     (
  86         mesh,
  87         streamData
  88     );
  89 }
  90
  91
  92 // Return weighting factors for scheme given by name in dictionary
  93 template<class Type>
  94 tmp<edgeInterpolationScheme<Type> > scheme
  95 (
  96     const faMesh& mesh,
  97     const word& name
  98 )
  99 {
 100     return edgeInterpolationScheme<Type>::New
 101     (
 102         mesh,
 103         mesh.schemesDict().interpolationScheme(name)
 104     );
 105 }
 106
 107
 108 // Interpolate field onto faces using scheme given by name in dictionary
 109 template<class Type>
 110 tmp<GeometricField<Type, faePatchField, edgeMesh> >
 111 interpolate
 112 (
 113     const GeometricField<Type, faPatchField, areaMesh>& vf,
 114     const edgeScalarField& faceFlux,
 115     Istream& schemeData
 116 )
 117 {
 118 #   ifdef DEBUGInterpolations
 119     if (edgeInterpolation::debug)
 120     {
 121         Info<< "interpolate"
 122             << "(const GeometricField<Type, faPatchField, areaMesh>&, "
 123             << "const edgeScalarField&, Istream&) : "
 124             << "interpolating GeometricField<Type, faPatchField, areaMesh> "
 125             << endl;
 126     }
 127 #   endif
 128
 129     return scheme<Type>(faceFlux, schemeData)().interpolate(vf);
 130 }
 131
 132
 133 // Interpolate field onto faces using scheme given by name in dictionary
 134 template<class Type>
 135 tmp<GeometricField<Type, faePatchField, edgeMesh> >
 136 interpolate
 137 (
 138     const GeometricField<Type, faPatchField, areaMesh>& vf,
 139     const edgeScalarField& faceFlux,
 140     const word& name
 141 )
 142 {
 143 #   ifdef DEBUGInterpolations
 144     if (edgeInterpolation::debug)
 145     {
 146         Info<< "interpolate"
 147             << "(const GeometricField<Type, faPatchField, areaMesh>&, "
 148             << "const edgeScalarField&, const word&) : "
 149             << "interpolating GeometricField<Type, faPatchField, areaMesh> "
 150             << "using " << name
 151             << endl;
 152     }
 153 #   endif
 154
 155     return scheme<Type>(faceFlux, name)().interpolate(vf);
 156 }
 157
 158 // Interpolate field onto faces using scheme given by name in dictionary
 159 template<class Type>
 160 tmp<GeometricField<Type, faePatchField, edgeMesh> >
 161 interpolate
 162 (
 163     const tmp<GeometricField<Type, faPatchField, areaMesh> >& tvf,
 164     const edgeScalarField& faceFlux,
 165     const word& name
 166 )
 167 {
 168     tmp<GeometricField<Type, faePatchField, edgeMesh> > tsf =
 169         interpolate(tvf(), faceFlux, name);
 170
 171     tvf.clear();
 172
 173     return tsf;
 174 }
 175
 176 // Interpolate field onto faces using scheme given by name in dictionary
 177 template<class Type>
 178 tmp<GeometricField<Type, faePatchField, edgeMesh> >
 179 interpolate
 180 (
 181     const GeometricField<Type, faPatchField, areaMesh>& vf,
 182     const tmp<edgeScalarField>& tFaceFlux,
 183     const word& name
 184 )
 185 {
 186     tmp<GeometricField<Type, faePatchField, edgeMesh> > tsf =
 187         interpolate(vf, tFaceFlux(), name);
 188
 189     tFaceFlux.clear();
 190
 191     return tsf;
 192 }
 193
 194 // Interpolate field onto faces using scheme given by name in dictionary
 195 template<class Type>
 196 tmp<GeometricField<Type, faePatchField, edgeMesh> >
 197 interpolate
 198 (
 199     const tmp<GeometricField<Type, faPatchField, areaMesh> >& tvf,
 200     const tmp<edgeScalarField>& tFaceFlux,
 201     const word& name
 202 )
 203 {
 204     tmp<GeometricField<Type, faePatchField, edgeMesh> > tsf =
 205         interpolate(tvf(), tFaceFlux(), name);
 206
 207     tvf.clear();
 208     tFaceFlux.clear();
 209
 210     return tsf;
 211 }
 212
 213
 214 // Interpolate field onto faces using scheme given by name in dictionary
 215 template<class Type>
 216 tmp<GeometricField<Type, faePatchField, edgeMesh> >
 217 interpolate
 218 (
 219     const GeometricField<Type, faPatchField, areaMesh>& vf,
 220     Istream& schemeData
 221 )
 222 {
 223 #   ifdef DEBUGInterpolations
 224     if (edgeInterpolation::debug)
 225     {
 226         Info<< "interpolate"
 227             << "(const GeometricField<Type, faPatchField, areaMesh>&, "
 228             << "Istream&) : "
 229             << "interpolating GeometricField<Type, faPatchField, areaMesh> "
 230             << endl;
 231     }
 232 #   endif
 233
 234     return scheme<Type>(vf.mesh(), schemeData)().interpolate(vf);
 235 }
 236
 237 // Interpolate field onto faces using scheme given by name in dictionary
 238 template<class Type>
 239 tmp<GeometricField<Type, faePatchField, edgeMesh> >
 240 interpolate
 241 (
 242     const GeometricField<Type, faPatchField, areaMesh>& vf,
 243     const word& name
 244 )
 245 {
 246 #   ifdef DEBUGInterpolations
 247     if (edgeInterpolation::debug)
 248     {
 249         Info<< "interpolate"
 250             << "(const GeometricField<Type, faPatchField, areaMesh>&, "
 251             << "const word&) : "
 252             << "interpolating GeometricField<Type, faPatchField, areaMesh> "
 253             << "using " << name
 254             << endl;
 255     }
 256 #   endif
 257
 258     return scheme<Type>(vf.mesh(), name)().interpolate(vf);
 259 }
 260
 261 // Interpolate field onto faces using scheme given by name in dictionary
 262 template<class Type>
 263 tmp<GeometricField<Type, faePatchField, edgeMesh> >
 264 interpolate
 265 (
 266     const tmp<GeometricField<Type, faPatchField, areaMesh> >& tvf,
 267     const word& name
 268 )
 269 {
 270     tmp<GeometricField<Type, faePatchField, edgeMesh> > tsf =
 271         interpolate(tvf(), name);
 272
 273     tvf.clear();
 274
 275     return tsf;
 276 }
 277
 278
 279 // Interpolate field onto faces using central differencing
 280 template<class Type>
 281 tmp<GeometricField<Type, faePatchField, edgeMesh> >
 282 interpolate
 283 (
 284     const GeometricField<Type, faPatchField, areaMesh>& vf
 285 )
 286 {
 287
 288 #   ifdef DEBUGInterpolations
 289     if (edgeInterpolation::debug)
 290     {
 291         Info<< "interpolate"
 292             << "(const GeometricField<Type, faPatchField, areaMesh>&) : "
 293             << "interpolating GeometricField<Type, faPatchField, areaMesh> "
 294             << "using run-time selected scheme"
 295             << endl;
 296     }
 297 #   endif
 298
 299     return interpolate(vf, "interpolate(" + vf.name() + ')');
 300 }
 301
 302
 303 // Interpolate field onto faces using central differencing
 304 template<class Type>
 305 tmp<GeometricField<Type, faePatchField, edgeMesh> >
 306 interpolate
 307 (
 308     const tmp<GeometricField<Type, faPatchField, areaMesh> >& tvf
 309 )
 310 {
 311     tmp<GeometricField<Type, faePatchField, edgeMesh> > tsf =
 312         interpolate(tvf());
 313     tvf.clear();
 314     return tsf;
 315 }
 316
 317
 318 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 319
 320 } // End namespace fac
 321
 322 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 323
 324 } // End namespace Foam
 325
 326 // ************************************************************************* //