src/OpenFOAM/meshes/polyMesh/polyPatches/basic/coupled/coupledPolyPatch.H

   1 /*---------------------------------------------------------------------------*\
   2   =========                 |
   3   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
   4    \\    /   O peration     |
   5     \\  /    A nd           | Copyright (C) 1991-2008 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 the
  13     Free Software Foundation; either version 2 of the License, or (at your
  14     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, write to the Free Software Foundation,
  23     Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
  24
  25 Class
  26     Foam::coupledPolyPatch
  27
  28 Description
  29     The coupledPolyPatch is an abstract base class for patches that couple
  30     regions of the computational domain e.g. cyclic and processor-processor
  31     links.
  32
  33 SourceFiles
  34     coupledPolyPatch.C
  35     coupledPolyPatchMorph.C
  36
  37 \*---------------------------------------------------------------------------*/
  38
  39 #ifndef coupledPolyPatch_H
  40 #define coupledPolyPatch_H
  41
  42 #include "polyPatch.H"
  43
  44 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
  45
  46 namespace Foam
  47 {
  48
  49 /*---------------------------------------------------------------------------*\
  50                        Class coupledPolyPatch Declaration
  51 \*---------------------------------------------------------------------------*/
  52
  53 class coupledPolyPatch
  54 :
  55     public polyPatch
  56 {
  57     // Private data
  58
  59         //- offset (distance) vector from one side of the couple to the other
  60         mutable vectorField separation_;
  61
  62         //- Face transformation tensor
  63         mutable tensorField forwardT_;
  64
  65         //- Neighbour-cell transformation tensor
  66         mutable tensorField reverseT_;
  67
  68 public:
  69
  70     // Static data members
  71
  72         //- Relative tolerance (for geometric matching).
  73         static scalar matchTol;
  74
  75
  76 protected:
  77
  78     // Protected Member Functions
  79
  80         //- Calculate the transformation tensors
  81         //  smallDist : matching distance per face
  82         //  absTol    : absolute error in normal
  83         void calcTransformTensors
  84         (
  85             const vectorField& Cf,
  86             const vectorField& Cr,
  87             const vectorField& nf,
  88             const vectorField& nr,
  89             const scalarField& smallDist,
  90             const scalar absTol = matchTol
  91         ) const;
  92
  93         //- Initialise the calculation of the patch geometry
  94         virtual void initGeometry() = 0;
  95
  96         //- Calculate the patch geometry
  97         virtual void calcGeometry() = 0;
  98
  99         //- Initialise the patches for moving points
 100         virtual void initMovePoints(const pointField&) = 0;
 101
 102         //- Correct patches after moving points
 103         virtual void movePoints(const pointField&) = 0;
 104
 105         //- Initialise the update of the patch topology
 106         virtual void initUpdateMesh() = 0;
 107
 108         //- Update of the patch topology
 109         virtual void updateMesh() = 0;
 110
 111
 112         //- Write point in OBJ format
 113         static void writeOBJ(Ostream& os, const point& pt);
 114
 115         //- Write selected points in OBJ format
 116         static void writeOBJ(Ostream&, const pointField&, const labelList&);
 117
 118         //- Write patch
 119         static void writeOBJ
 120         (
 121             const fileName&,
 122             const UList<face>&,
 123             const pointField&
 124         );
 125
 126         //- Write edge in OBJ format
 127         static void writeOBJ
 128         (
 129             Ostream& os,
 130             const point& p0,
 131             const point& p1,
 132             label& vertI
 133         );
 134
 135         //- Calculate face centres
 136         static pointField calcFaceCentres
 137         (
 138             const UList<face>&,
 139             const pointField&
 140         );
 141
 142         //- Get f[0] for all faces
 143         static pointField getAnchorPoints
 144         (
 145             const UList<face>&,
 146             const pointField&
 147         );
 148
 149         //- Is face (in old face labels) in current patch?
 150         bool inPatch
 151         (
 152             const labelList& oldToNew,
 153             const label oldFaceI
 154         ) const;
 155
 156         //- Given list of starts of patches and a face label determine
 157         //  the patch.
 158         static label whichPatch
 159         (
 160             const labelList& patchStarts,
 161             const label faceI
 162         );
 163
 164         //- Calculate typical tolerance per face. Is currently max distance
 165         //  from face centre to any of the face vertices.
 166         static scalarField calcFaceTol
 167         (
 168             const UList<face>& faces,
 169             const pointField& points,
 170             const pointField& faceCentres
 171         );
 172
 173         //- Get the number of vertices face f needs to be rotated such that
 174         //  its f[0] point aligns with given anchor (within tol).
 175         static label getRotation
 176         (
 177             const pointField& points,
 178             const face& f,
 179             const point& anchor,
 180             const scalar tol
 181         );
 182
 183
 184 public:
 185
 186     //- Runtime type information
 187     TypeName("coupled");
 188
 189
 190     // Constructors
 191
 192         //- Construct from components
 193         coupledPolyPatch
 194         (
 195             const word& name,
 196             const label size,
 197             const label start,
 198             const label index,
 199             const polyBoundaryMesh& bm
 200         );
 201
 202         //- Construct from dictionary
 203         coupledPolyPatch
 204         (
 205             const word& name,
 206             const dictionary& dict,
 207             const label index,
 208             const polyBoundaryMesh& bm
 209         );
 210
 211         //- Construct as copy, resetting the boundary mesh
 212         coupledPolyPatch(const coupledPolyPatch&, const polyBoundaryMesh&);
 213
 214         //- Construct given the original patch and resetting the
 215         //  face list and boundary mesh information
 216         coupledPolyPatch
 217         (
 218             const coupledPolyPatch& pp,
 219             const polyBoundaryMesh& bm,
 220             const label index,
 221             const label newSize,
 222             const label newStart
 223         );
 224
 225
 226     // Destructor
 227
 228         virtual ~coupledPolyPatch();
 229
 230
 231     // Member Functions
 232
 233         // Access
 234
 235             //- Return true because this patch is coupled
 236             virtual bool coupled() const
 237             {
 238                 return true;
 239             }
 240
 241
 242             //- Are the coupled planes separated
 243             bool separated() const
 244             {
 245                 return separation_.size();
 246             }
 247
 248             //- Return the offset (distance) vector from one side of the couple
 249             //  to the other
 250             const vectorField& separation() const
 251             {
 252                 return separation_;
 253             }
 254
 255
 256             //- Are the cyclic planes parallel
 257             bool parallel() const
 258             {
 259                 return forwardT_.size() == 0;
 260             }
 261
 262             //- Return face transformation tensor
 263             const tensorField& forwardT() const
 264             {
 265                 return forwardT_;
 266             }
 267
 268             //- Return neighbour-cell transformation tensor
 269             const tensorField& reverseT() const
 270             {
 271                 return reverseT_;
 272             }
 273
 274
 275         //- Initialize ordering for primitivePatch. Does not
 276         //  refer to *this (except for name() and type() etc.)
 277         virtual void initOrder(const primitivePatch&) const = 0;
 278
 279         //- Return new ordering for primitivePatch.
 280         //  Ordering is -faceMap: for every face
 281         //  index of the new face -rotation:for every new face the clockwise
 282         //  shift of the original face. Return false if nothing changes
 283         //  (faceMap is identity, rotation is 0), true otherwise.
 284         virtual bool order
 285         (
 286             const primitivePatch&,
 287             labelList& faceMap,
 288             labelList& rotation
 289         ) const = 0;
 290 };
 291
 292
 293 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 294
 295 } // End namespace Foam
 296
 297 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 298
 299 #endif
 300
 301 // ************************************************************************* //