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 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  (
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
193  {
194  return alg_;
195  }
196 
197  //- Return direction projection to use in projection
199  {
200  return dir_;
201  }
202 
203  //- Return distance to intersection for patch points
205 
206  //- Return distance to intersection for patch face centres
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 // ************************************************************************* //
Interpolation class dealing with transfer of data between two primitivePatches.
const scalarField & pointDistanceToIntersection() const
Return distance to intersection for patch points.
Generic field type.
Definition: FieldField.H:51
Namespace for OpenFOAM.
tmp< Field< Type > > faceInterpolate(const Field< Type > &pf) const
Interpolate face field.
tmp< Field< Type > > pointInterpolate(const Field< Type > &pf) const
Interpolate point field.
Macro definitions for declaring ClassName(), NamespaceName(), etc.
static scalar setProjectionTol(const scalar t)
Set the projection tolerance, returning the previous value.
bool movePoints()
Correct weighting factors for moving mesh.
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.
#define FatalErrorIn(functionName)
Report an error message using Foam::FatalError.
Definition: error.H:314
const scalarField & faceDistanceToIntersection() const
Return distance to intersection for patch face centres.
error FatalError
TemplateName(blendedSchemeBase)
A class for managing temporary objects.
Definition: PtrList.H:118