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) 2004-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     ~PatchToPatchInterpolation();
 168
 169
 170     // Member Functions
 171
 172         //- Set the projection tolerance, returning the previous value
 173         static scalar setProjectionTol(const scalar t)
 174         {
 175             if (t < -VSMALL)
 176             {
 177                 FatalErrorIn
 178                 (
 179                     "scalar PatchToPatchInterpolation::"
 180                     "setProjectionTol(const scalar t)"
 181                 )   << "Negative projection tolerance.  This is not allowed."
 182                     << abort(FatalError);
 183             }
 184
 185             scalar oldTol = projectionTol_;
 186             projectionTol_ = t;
 187
 188             return oldTol;
 189         }
 190
 191         //- Return ype of intersection algorithm to use in projection
 192         intersection::algorithm projectionAlgo() const
 193         {
 194             return alg_;
 195         }
 196
 197         //- Return direction projection to use in projection
 198         intersection::direction projectionDir() const
 199         {
 200             return dir_;
 201         }
 202
 203         //- Return distance to intersection for patch points
 204         const scalarField& pointDistanceToIntersection() const;
 205
 206         //- Return distance to intersection for patch face centres
 207         const scalarField& faceDistanceToIntersection() const;
 208
 209         //- Correct weighting factors for moving mesh.
 210         bool movePoints();
 211
 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(const tmp<Field<Type> >& tpf) const;
 219
 220         //- Interpolate face field
 221         template<class Type>
 222         tmp<Field<Type> > faceInterpolate(const Field<Type>& pf) const;
 223
 224         template<class Type>
 225         tmp<Field<Type> > faceInterpolate(const tmp<Field<Type> >& tpf) const;
 226
 227 };
 228
 229
 230 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 231
 232 } // End namespace Foam
 233
 234 #ifdef NoRepository
 235 #   include "PatchToPatchInterpolation.C"
 236 #endif
 237
 238 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 239
 240 #endif
 241
 242 // ************************************************************************* //