ENH: coupledPolyPatch.H : expose tolerance calculation
[OpenFOAM-2.0.x.git] / src / OpenFOAM / meshes / polyMesh / polyPatches / basic / coupled / coupledPolyPatch.H
blobb3368d5cfbb77a8d3f4dcf481d621759aab0ee95
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.
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.
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.
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/>.
24 Class
25     Foam::coupledPolyPatch
27 Description
28     The coupledPolyPatch is an abstract base class for patches that couple
29     regions of the computational domain e.g. cyclic and processor-processor
30     links.
32 SourceFiles
33     coupledPolyPatch.C
35 \*---------------------------------------------------------------------------*/
37 #ifndef coupledPolyPatch_H
38 #define coupledPolyPatch_H
40 #include "polyPatch.H"
41 #include "diagTensorField.H"
43 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
45 namespace Foam
48 /*---------------------------------------------------------------------------*\
49                       Class coupledPolyPatch Declaration
50 \*---------------------------------------------------------------------------*/
52 class coupledPolyPatch
54     public polyPatch
56 public:
58     enum transformType
59     {
60         UNKNOWN,            // unspecified; automatic ordering
61         ROTATIONAL,         // rotation along coordinate axis
62         TRANSLATIONAL,      // translation
63         NOORDERING          // unspecified, no automatic ordering
64     };
65     static const NamedEnum<transformType, 4> transformTypeNames;
68 private:
70     // Private data
72         //- default matching tolerance
73         static const scalar defaultMatchTol_;
75         //- local matching tolerance
76         const scalar matchTolerance_;
78         //- offset (distance) vector from one side of the couple to the other
79         mutable vectorField separation_;
81         //- Face transformation tensor
82         mutable tensorField forwardT_;
84         //- Neighbour-cell transformation tensor
85         mutable tensorField reverseT_;
87         //- Are faces collocated. Either size 0,1 or length of patch.
88         mutable boolList collocated_;
90 protected:
92     // Protected Member Functions
94         //- Calculate the transformation tensors
95         //  smallDist : matching distance per face
96         //  absTol    : absolute error in normal
97         //  if transformType = unknown it first tries rotational, then
98         //  translational transform
99         void calcTransformTensors
100         (
101             const vectorField& Cf,
102             const vectorField& Cr,
103             const vectorField& nf,
104             const vectorField& nr,
105             const scalarField& smallDist,
106             const scalar absTol,
107             const transformType = UNKNOWN
108         ) const;
110         //- Initialise the calculation of the patch geometry
111         virtual void initGeometry(PstreamBuffers&) = 0;
113         //- Calculate the patch geometry
114         virtual void calcGeometry(PstreamBuffers&) = 0;
116         //- Initialise the patches for moving points
117         virtual void initMovePoints(PstreamBuffers&, const pointField&) = 0;
119         //- Correct patches after moving points
120         virtual void movePoints(PstreamBuffers&, const pointField&) = 0;
122         //- Initialise the update of the patch topology
123         virtual void initUpdateMesh(PstreamBuffers&) = 0;
125         //- Update of the patch topology
126         virtual void updateMesh(PstreamBuffers&) = 0;
129         //- Write point in OBJ format
130         static void writeOBJ(Ostream& os, const point& pt);
132         //- Write selected points in OBJ format
133         static void writeOBJ(Ostream&, const pointField&, const labelList&);
135         //- Write patch
136         static void writeOBJ
137         (
138             const fileName&,
139             const UList<face>&,
140             const pointField&
141         );
143         //- Write edge in OBJ format
144         static void writeOBJ
145         (
146             Ostream& os,
147             const point& p0,
148             const point& p1,
149             label& vertI
150         );
152         //- Get f[0] for all faces
153         static pointField getAnchorPoints
154         (
155             const UList<face>&,
156             const pointField&
157         );
159         //- Get the number of vertices face f needs to be rotated such that
160         //  its f[0] point aligns with given anchor (within tol).
161         static label getRotation
162         (
163             const pointField& points,
164             const face& f,
165             const point& anchor,
166             const scalar tol
167         );
170 public:
172     //- Runtime type information
173     TypeName("coupled");
176     // Constructors
178         //- Construct from components
179         coupledPolyPatch
180         (
181             const word& name,
182             const label size,
183             const label start,
184             const label index,
185             const polyBoundaryMesh& bm
186         );
188         //- Construct from dictionary
189         coupledPolyPatch
190         (
191             const word& name,
192             const dictionary& dict,
193             const label index,
194             const polyBoundaryMesh& bm
195         );
197         //- Construct as copy, resetting the boundary mesh
198         coupledPolyPatch(const coupledPolyPatch&, const polyBoundaryMesh&);
200         //- Construct given the original patch and resetting the
201         //  face list and boundary mesh information
202         coupledPolyPatch
203         (
204             const coupledPolyPatch& pp,
205             const polyBoundaryMesh& bm,
206             const label index,
207             const label newSize,
208             const label newStart
209         );
211         //- Construct given the original patch and a map
212         coupledPolyPatch
213         (
214             const coupledPolyPatch& pp,
215             const polyBoundaryMesh& bm,
216             const label index,
217             const labelUList& mapAddressing,
218             const label newStart
219         );
222     //- Destructor
223     virtual ~coupledPolyPatch();
226     // Member Functions
228         // Access
230             //- Return true because this patch is coupled
231             virtual bool coupled() const
232             {
233                 return true;
234             }
236             //- Does this side own the patch ?
237             virtual bool owner() const = 0;
239             //- Does the coupled side own the patch ?
240             virtual bool neighbour() const
241             {
242                 return !owner();
243             }
245             //- Transform a patch-based position from other side to this side
246             virtual void transformPosition(pointField&) const = 0;
248             //- Transform a patch-based position from other side to this side
249             virtual void transformPosition(point&, const label facei) const = 0;
251             //- Are the planes separated.
252             virtual bool separated() const
253             {
254                 return separation_.size();
255             }
257             //- If the planes are separated the separation vector.
258             virtual const vectorField& separation() const
259             {
260                 return separation_;
261             }
263             //- Are the cyclic planes parallel.
264             virtual bool parallel() const
265             {
266                 return forwardT_.empty();
267             }
269             //- Return face transformation tensor.
270             virtual const tensorField& forwardT() const
271             {
272                 return forwardT_;
273             }
275             //- Return neighbour-cell transformation tensor.
276             virtual const tensorField& reverseT() const
277             {
278                 return reverseT_;
279             }
281             //- Are faces collocated. Either size 0,1 or length of patch
282             virtual const boolList& collocated() const
283             {
284                 return collocated_;
285             }
287             scalar matchTolerance() const
288             {
289                 return matchTolerance_;
290             }
293         //- Calculate the patch geometry
294         virtual void calcGeometry
295         (
296             const primitivePatch& referPatch,
297             const pointField& thisCtrs,
298             const vectorField& thisAreas,
299             const pointField& thisCc,
300             const pointField& nbrCtrs,
301             const vectorField& nbrAreas,
302             const pointField& nbrCc
303         ) = 0;
305         //- Initialize ordering for primitivePatch. Does not
306         //  refer to *this (except for name() and type() etc.)
307         virtual void initOrder
308         (
309             PstreamBuffers&,
310             const primitivePatch&
311         ) const = 0;
313         //- Return new ordering for primitivePatch.
314         //  Ordering is -faceMap: for every face
315         //  index of the new face -rotation:for every new face the clockwise
316         //  shift of the original face. Return false if nothing changes
317         //  (faceMap is identity, rotation is 0), true otherwise.
318         virtual bool order
319         (
320             PstreamBuffers&,
321             const primitivePatch&,
322             labelList& faceMap,
323             labelList& rotation
324         ) const = 0;
326         //- Calculate typical tolerance per face. Is currently max distance
327         //  from face centre to any of the face vertices.
328         static scalarField calcFaceTol
329         (
330             const scalar matchTol,
331             const UList<face>& faces,
332             const pointField& points,
333             const pointField& faceCentres
334         );
336         //- Write the polyPatch data as a dictionary
337         virtual void write(Ostream&) const;
341 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
343 } // End namespace Foam
345 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
347 #endif
349 // ************************************************************************* //