src/foam/interpolations/patchToPatchInterpolation/PatchToPatchInterpolationTemplate.H

   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 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 #include "tolerancesSwitch.H"
  49
  50 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
  51
  52 namespace Foam
  53 {
  54
  55 /*---------------------------------------------------------------------------*\
  56                 Class PatchToPatchInterpolationName Declaration
  57 \*---------------------------------------------------------------------------*/
  58
  59 TemplateName(PatchToPatchInterpolation);
  60
  61
  62 /*---------------------------------------------------------------------------*\
  63                   Class PatchToPatchInterpolation Declaration
  64 \*---------------------------------------------------------------------------*/
  65
  66 template<class FromPatch, class ToPatch>
  67 class PatchToPatchInterpolation
  68 :
  69     public PatchToPatchInterpolationName
  70 {
  71     // Private data
  72
  73         //- Reference to the source patch
  74         const FromPatch& fromPatch_;
  75
  76         //- Reference to the target patch
  77         const ToPatch& toPatch_;
  78
  79         //- Type of intersection algorithm to use in projection
  80         intersection::algorithm alg_;
  81
  82         //- Direction projection to use in projection
  83         intersection::direction dir_;
  84
  85
  86     // Static data
  87
  88         //- Relative merge tolerance for projected points missing the target
  89         //  Expressed as the fraction of min involved edge size
  90         static const debug::tolerancesSwitch projectionTol_;
  91
  92         //- Direct hit tolerance
  93         static const debug::tolerancesSwitch directHitTol_;
  94
  95
  96         // Point addressing
  97
  98             //- Face into which each point of target patch is projected
  99             mutable labelList* pointAddressingPtr_;
 100
 101             //- Weighting factors
 102             mutable FieldField<Field, scalar>* pointWeightsPtr_;
 103
 104             //- Distance to intersection for patch points
 105             mutable scalarField* pointDistancePtr_;
 106
 107
 108         // Face addressing
 109
 110             //- Face into which each face centre of target patch is projected
 111             mutable labelList* faceAddressingPtr_;
 112
 113             //- Weighting factors
 114             mutable FieldField<Field, scalar>* faceWeightsPtr_;
 115
 116             //- Distance to intersection for patch face centres
 117             mutable scalarField* faceDistancePtr_;
 118
 119
 120     // Private Member Functions
 121
 122         //- Disallow default bitwise assignment
 123         void operator=(const PatchToPatchInterpolation&);
 124
 125         //- Calculate point weights
 126         void calcPointAddressing() const;
 127
 128         //- Calculate face weights
 129         void calcFaceAddressing() const;
 130
 131         //- Clear all geometry and addressing
 132         void clearOut();
 133
 134
 135 protected:
 136
 137     // Protected member functions
 138
 139         //- Set weights when read from file
 140         void setWeights
 141         (
 142             labelList* paPtr,
 143             FieldField<Field, scalar>* pwPtr,
 144             scalarField* pdPtr,
 145             labelList* faPtr,
 146             FieldField<Field, scalar>* fwPtr,
 147             scalarField* fdPtr
 148         );
 149
 150
 151 public:
 152
 153     // Constructors
 154
 155         //- Construct from components
 156         PatchToPatchInterpolation
 157         (
 158             const FromPatch& fromPatch,
 159             const ToPatch& toPatch,
 160             const intersection::algorithm alg = intersection::FULL_RAY,
 161             const intersection::direction dir = intersection::VECTOR
 162         );
 163
 164         //- Construct as copy
 165         PatchToPatchInterpolation
 166         (
 167             const PatchToPatchInterpolation<FromPatch, ToPatch>&
 168         );
 169
 170
 171     // Destructor
 172
 173         ~PatchToPatchInterpolation();
 174
 175
 176     // Member Functions
 177
 178         // Access
 179
 180             //- Return ype of intersection algorithm to use in projection
 181             intersection::algorithm projectionAlgo() const
 182             {
 183                 return alg_;
 184             }
 185
 186             //- Return direction projection to use in projection
 187             intersection::direction projectionDir() const
 188             {
 189                 return dir_;
 190             }
 191
 192             //- Return reference to point addressing
 193             const labelList& pointAddr() const;
 194
 195             //- Return reference to point weights
 196             const FieldField<Field, scalar>& pointWeights() const;
 197
 198             //- Return reference to face addressing
 199             const labelList& faceAddr() const;
 200
 201             //- Return reference to face weights
 202             const FieldField<Field, scalar>& faceWeights() const;
 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
 211         // Interpolation functions
 212
 213             //- Interpolate point field
 214             template<class Type>
 215             tmp<Field<Type> > pointInterpolate(const Field<Type>& pf) const;
 216
 217             template<class Type>
 218             tmp<Field<Type> > pointInterpolate
 219             (
 220                 const tmp<Field<Type> >& tpf
 221             ) const;
 222
 223             //- Interpolate face field
 224             template<class Type>
 225             tmp<Field<Type> > faceInterpolate(const Field<Type>& pf) const;
 226
 227             template<class Type>
 228             tmp<Field<Type> > faceInterpolate
 229             (
 230                 const tmp<Field<Type> >& tpf
 231             ) const;
 232
 233
 234         // Edit
 235
 236             //- Correct weighting factors for moving mesh.
 237             bool movePoints();
 238 };
 239
 240
 241 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 242
 243 } // End namespace Foam
 244
 245 #ifdef NoRepository
 246 #   include "PatchToPatchInterpolationTemplate.C"
 247 #endif
 248
 249 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 250
 251 #endif
 252
 253 // ************************************************************************* //