FreeFOAM The Cross-Platform CFD Toolkit
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) 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 <OpenFOAM/className.H>
42 #include <OpenFOAM/labelList.H>
43 #include <OpenFOAM/scalarField.H>
44 #include <OpenFOAM/pointField.H>
45 #include <OpenFOAM/FieldFields.H>
46 #include <OpenFOAM/faceList.H>
47 #include <OpenFOAM/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
167 
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  {
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
194  {
195  return alg_;
196  }
197 
198  //- Return direction projection to use in projection
200  {
201  return dir_;
202  }
203 
204  //- Return distance to intersection for patch points
206 
207  //- Return distance to intersection for patch face centres
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
237 #endif
238 
239 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
240 
241 #endif
242 
243 // ************************ vim: set sw=4 sts=4 et: ************************ //