src/OpenFOAM/interpolations/patchToPatchInterpolation/PatchToPatchInterpolation.H

   1 /*---------------------------------------------------------------------------*\
   2   =========                 |
   3   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
   4    \\    /   O peration     |
   5     \\  /    A nd           | Copyright (C) 1991-2010 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
  13     the Free Software Foundation, either version 3 of the License, or
  14     (at your 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, see <http://www.gnu.org/licenses/>.
  23
  24 Class
  25     Foam::PatchToPatchInterpolation
  26
  27 Description
  28     Interpolation class dealing with transfer of data between two
  29     primitivePatches
  30
  31 SourceFiles
  32     PatchToPatchInterpolation.C
  33     PatchToPatchInterpolate.C
  34     CalcPatchToPatchWeights.C
  35
  36 \*---------------------------------------------------------------------------*/
  37
  38 #ifndef PatchToPatchInterpolation_H
  39 #define PatchToPatchInterpolation_H
  40
  41 #include "className.H"
  42 #include "labelList.H"
  43 #include "scalarField.H"
  44 #include "pointField.H"
  45 #include "FieldFields.H"
  46 #include "faceList.H"
  47 #include "intersection.H"
  48
  49 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
  50
  51 namespace Foam
  52 {
  53
  54 /*---------------------------------------------------------------------------*\
  55                 Class PatchToPatchInterpolationName Declaration
  56 \*---------------------------------------------------------------------------*/
  57
  58 TemplateName(PatchToPatchInterpolation);
  59
  60
  61 /*---------------------------------------------------------------------------*\
  62                   Class PatchToPatchInterpolation Declaration
  63 \*---------------------------------------------------------------------------*/
  64
  65 template<class FromPatch, class ToPatch>
  66 class PatchToPatchInterpolation
  67 :
  68     public PatchToPatchInterpolationName
  69 {
  70     // Private data
  71
  72         //- Reference to the source patch
  73         const FromPatch& fromPatch_;
  74
  75         //- Reference to the target patch
  76         const ToPatch& toPatch_;
  77
  78         //- Type of intersection algorithm to use in projection
  79         intersection::algorithm alg_;
  80
  81         //- Direction projection to use in projection
  82         intersection::direction dir_;
  83
  84
  85     // Static data
  86
  87         //- Relative merge tolerance for projected points missing the target
  88         //  Expressed as the fraction of min involved edge size
  89         static scalar projectionTol_;
  90
  91
  92         // Point addressing
  93
  94             //- Face into which each point of target patch is projected
  95             mutable labelList* pointAddressingPtr_;
  96
  97             //- Weighting factors
  98             mutable FieldField<Field, scalar>* pointWeightsPtr_;
  99
 100             //- Distance to intersection for patch points
 101             mutable scalarField* pointDistancePtr_;
 102
 103         // Face addressing
 104
 105             //- Face into which each face centre of target patch is projected
 106             mutable labelList* faceAddressingPtr_;
 107
 108             //- Weighting factors
 109             mutable FieldField<Field, scalar>* faceWeightsPtr_;
 110
 111             //- Distance to intersection for patch face centres
 112             mutable scalarField* faceDistancePtr_;
 113
 114
 115     // Private Member Functions
 116
 117         //- Disallow default bitwise copy construct
 118         PatchToPatchInterpolation(const PatchToPatchInterpolation&);
 119
 120         //- Disallow default bitwise assignment
 121         void operator=(const PatchToPatchInterpolation&);
 122
 123         //- Calculate point weights
 124         void calcPointAddressing() const;
 125
 126         //- Calculate face weights
 127         void calcFaceAddressing() const;
 128
 129         //- Clear all geometry and addressing
 130         void clearOut();
 131
 132
 133         //- Return reference to point addressing
 134         const labelList& pointAddr() const;
 135
 136         //- Return reference to point weights
 137         const FieldField<Field, scalar>& pointWeights() const;
 138
 139         //- Return reference to face addressing
 140         const labelList& faceAddr() const;
 141
 142         //- Return reference to face weights
 143         const FieldField<Field, scalar>& faceWeights() const;
 144
 145
 146     // Private static data members
 147
 148         //- Direct hit tolerance
 149         static const scalar directHitTol;
 150
 151
 152 public:
 153
 154     // Constructors
 155
 156         //- Construct from components
 157         PatchToPatchInterpolation
 158         (
 159             const FromPatch& fromPatch,
 160             const ToPatch& toPatch,
 161             const intersection::algorithm alg = intersection::FULL_RAY,
 162             const intersection::direction dir = intersection::VECTOR
 163         );
 164
 165
 166     // Destructor
 167
 168         ~PatchToPatchInterpolation();
 169
 170
 171     // Member Functions
 172
 173         //- Set the projection tolerance, returning the previous value
 174         static scalar setProjectionTol(const scalar t)
 175         {
 176             if (t < -VSMALL)
 177             {
 178                 FatalErrorIn
 179                 (
 180                     "scalar PatchToPatchInterpolation::"
 181                     "setProjectionTol(const scalar t)"
 182                 )   << "Negative projection tolerance.  This is not allowed."
 183                     << abort(FatalError);
 184             }
 185
 186             scalar oldTol = projectionTol_;
 187             projectionTol_ = t;
 188
 189             return oldTol;
 190         }
 191
 192         //- Return ype of intersection algorithm to use in projection
 193         intersection::algorithm projectionAlgo() const
 194         {
 195             return alg_;
 196         }
 197
 198         //- Return direction projection to use in projection
 199         intersection::direction projectionDir() const
 200         {
 201             return dir_;
 202         }
 203
 204         //- Return distance to intersection for patch points
 205         const scalarField& pointDistanceToIntersection() const;
 206
 207         //- Return distance to intersection for patch face centres
 208         const scalarField& faceDistanceToIntersection() const;
 209
 210         //- Correct weighting factors for moving mesh.
 211         bool movePoints();
 212
 213
 214         //- Interpolate point field
 215         template<class Type>
 216         tmp<Field<Type> > pointInterpolate(const Field<Type>& pf) const;
 217
 218         template<class Type>
 219         tmp<Field<Type> > pointInterpolate(const tmp<Field<Type> >& tpf) const;
 220
 221         //- Interpolate face field
 222         template<class Type>
 223         tmp<Field<Type> > faceInterpolate(const Field<Type>& pf) const;
 224
 225         template<class Type>
 226         tmp<Field<Type> > faceInterpolate(const tmp<Field<Type> >& tpf) const;
 227
 228 };
 229
 230
 231 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 232
 233 } // End namespace Foam
 234
 235 #ifdef NoRepository
 236 #   include "PatchToPatchInterpolation.C"
 237 #endif
 238
 239 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 240
 241 #endif
 242
 243 // ************************************************************************* //