PatchToPatchInterpolation.H
Go to the documentation of this file.
1 /*---------------------------------------------------------------------------*\
2  ========= |
3  \\ / F ield | OpenFOAM: The Open Source CFD Toolbox
4  \\ / O peration |
5  \\ / A nd | Copyright (C) 2011-2016 OpenFOAM Foundation
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>
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
80 
81  //- Direction projection to use in projection
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
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
158  (
159  const FromPatch& fromPatch,
160  const ToPatch& toPatch,
163  );
164 
165 
166  //- Destructor
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  {
178  << abort(FatalError);
179  }
180 
181  scalar oldTol = projectionTol_;
182  projectionTol_ = t;
183 
184  return oldTol;
185  }
186 
187  //- Return ype of intersection algorithm to use in projection
189  {
190  return alg_;
191  }
192 
193  //- Return direction projection to use in projection
195  {
196  return dir_;
197  }
198 
199  //- Return distance to intersection for patch points
201 
202  //- Return distance to intersection for patch face centres
204 
205  //- Correct weighting factors for moving mesh.
206  bool movePoints();
207 
208 
209  //- Interpolate point field
210  template<class Type>
211  tmp<Field<Type>> pointInterpolate(const Field<Type>& pf) const;
212 
213  template<class Type>
214  tmp<Field<Type>> pointInterpolate(const tmp<Field<Type>>& tpf) const;
215 
216  //- Interpolate face field
217  template<class Type>
218  tmp<Field<Type>> faceInterpolate(const Field<Type>& pf) const;
219 
220  template<class Type>
221  tmp<Field<Type>> faceInterpolate(const tmp<Field<Type>>& tpf) const;
222 
223 };
224 
225 
226 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
227 
228 } // End namespace Foam
229 
230 #ifdef NoRepository
231  #include "PatchToPatchInterpolation.C"
232 #endif
233 
234 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
235 
236 #endif
237 
238 // ************************************************************************* //
const scalarField & pointDistanceToIntersection() const
Return distance to intersection for patch points.
TemplateName(blendedSchemeBase)
error FatalError
#define FatalErrorInFunction
Report an error message using Foam::FatalError.
Definition: error.H:319
const scalarField & faceDistanceToIntersection() const
Return distance to intersection for patch face centres.
tmp< Field< Type > > faceInterpolate(const Field< Type > &pf) const
Interpolate face field.
Generic field type.
Definition: FieldField.H:51
tmp< Field< Type > > pointInterpolate(const Field< Type > &pf) const
Interpolate point field.
intersection::algorithm projectionAlgo() const
Return ype of intersection algorithm to use in projection.
errorManip< error > abort(error &err)
Definition: errorManip.H:131
intersection::direction projectionDir() const
Return direction projection to use in projection.
Macro definitions for declaring ClassName(), NamespaceName(), etc.
bool movePoints()
Correct weighting factors for moving mesh.
A class for managing temporary objects.
Definition: PtrList.H:54
static scalar setProjectionTol(const scalar t)
Set the projection tolerance, returning the previous value.
Interpolation class dealing with transfer of data between two primitivePatches.
Namespace for OpenFOAM.