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) 2004-2011 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::coupledPolyPatch
  26
  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.
  31
  32 SourceFiles
  33     coupledPolyPatch.C
  34
  35 \*---------------------------------------------------------------------------*/
  36
  37 #ifndef coupledPolyPatch_H
  38 #define coupledPolyPatch_H
  39
  40 #include "polyPatch.H"
  41 #include "diagTensorField.H"
  42
  43 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
  44
  45 namespace Foam
  46 {
  47
  48 /*---------------------------------------------------------------------------*\
  49                       Class coupledPolyPatch Declaration
  50 \*---------------------------------------------------------------------------*/
  51
  52 class coupledPolyPatch
  53 :
  54     public polyPatch
  55 {
  56 public:
  57
  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;
  66
  67
  68 private:
  69
  70     // Private data
  71
  72         //- default matching tolerance
  73         static const scalar defaultMatchTol_;
  74
  75         //- local matching tolerance
  76         const scalar matchTolerance_;
  77
  78         //- offset (distance) vector from one side of the couple to the other
  79         mutable vectorField separation_;
  80
  81         //- Face transformation tensor
  82         mutable tensorField forwardT_;
  83
  84         //- Neighbour-cell transformation tensor
  85         mutable tensorField reverseT_;
  86
  87         //- Are faces collocated. Either size 0,1 or length of patch.
  88         mutable boolList collocated_;
  89
  90 protected:
  91
  92     // Protected Member Functions
  93
  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;
 109
 110         //- Initialise the calculation of the patch geometry
 111         virtual void initGeometry(PstreamBuffers&) = 0;
 112
 113         //- Calculate the patch geometry
 114         virtual void calcGeometry(PstreamBuffers&) = 0;
 115
 116         //- Initialise the patches for moving points
 117         virtual void initMovePoints(PstreamBuffers&, const pointField&) = 0;
 118
 119         //- Correct patches after moving points
 120         virtual void movePoints(PstreamBuffers&, const pointField&) = 0;
 121
 122         //- Initialise the update of the patch topology
 123         virtual void initUpdateMesh(PstreamBuffers&) = 0;
 124
 125         //- Update of the patch topology
 126         virtual void updateMesh(PstreamBuffers&) = 0;
 127
 128
 129         //- Write point in OBJ format
 130         static void writeOBJ(Ostream& os, const point& pt);
 131
 132         //- Write selected points in OBJ format
 133         static void writeOBJ(Ostream&, const pointField&, const labelList&);
 134
 135         //- Write patch
 136         static void writeOBJ
 137         (
 138             const fileName&,
 139             const UList<face>&,
 140             const pointField&
 141         );
 142
 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         );
 151
 152         //- Get f[0] for all faces
 153         static pointField getAnchorPoints
 154         (
 155             const UList<face>&,
 156             const pointField&
 157         );
 158
 159         //- Calculate typical tolerance per face. Is currently max distance
 160         //  from face centre to any of the face vertices.
 161         static scalarField calcFaceTol
 162         (
 163             const scalar matchTol,
 164             const UList<face>& faces,
 165             const pointField& points,
 166             const pointField& faceCentres
 167         );
 168
 169         //- Get the number of vertices face f needs to be rotated such that
 170         //  its f[0] point aligns with given anchor (within tol).
 171         static label getRotation
 172         (
 173             const pointField& points,
 174             const face& f,
 175             const point& anchor,
 176             const scalar tol
 177         );
 178
 179
 180 public:
 181
 182     //- Runtime type information
 183     TypeName("coupled");
 184
 185
 186     // Constructors
 187
 188         //- Construct from components
 189         coupledPolyPatch
 190         (
 191             const word& name,
 192             const label size,
 193             const label start,
 194             const label index,
 195             const polyBoundaryMesh& bm
 196         );
 197
 198         //- Construct from dictionary
 199         coupledPolyPatch
 200         (
 201             const word& name,
 202             const dictionary& dict,
 203             const label index,
 204             const polyBoundaryMesh& bm
 205         );
 206
 207         //- Construct as copy, resetting the boundary mesh
 208         coupledPolyPatch(const coupledPolyPatch&, const polyBoundaryMesh&);
 209
 210         //- Construct given the original patch and resetting the
 211         //  face list and boundary mesh information
 212         coupledPolyPatch
 213         (
 214             const coupledPolyPatch& pp,
 215             const polyBoundaryMesh& bm,
 216             const label index,
 217             const label newSize,
 218             const label newStart
 219         );
 220
 221         //- Construct given the original patch and a map
 222         coupledPolyPatch
 223         (
 224             const coupledPolyPatch& pp,
 225             const polyBoundaryMesh& bm,
 226             const label index,
 227             const labelUList& mapAddressing,
 228             const label newStart
 229         );
 230
 231
 232     //- Destructor
 233     virtual ~coupledPolyPatch();
 234
 235
 236     // Member Functions
 237
 238         // Access
 239
 240             //- Return true because this patch is coupled
 241             virtual bool coupled() const
 242             {
 243                 return true;
 244             }
 245
 246             //- Does this side own the patch ?
 247             virtual bool owner() const = 0;
 248
 249             //- Does the coupled side own the patch ?
 250             virtual bool neighbour() const
 251             {
 252                 return !owner();
 253             }
 254
 255             //- Transform a patch-based position from other side to this side
 256             virtual void transformPosition(pointField&) const = 0;
 257
 258             //- Transform a patch-based position from other side to this side
 259             virtual void transformPosition(point&, const label facei) const = 0;
 260
 261             //- Are the planes separated.
 262             virtual bool separated() const
 263             {
 264                 return separation_.size();
 265             }
 266
 267             //- If the planes are separated the separation vector.
 268             virtual const vectorField& separation() const
 269             {
 270                 return separation_;
 271             }
 272
 273             //- Are the cyclic planes parallel.
 274             virtual bool parallel() const
 275             {
 276                 return forwardT_.empty();
 277             }
 278
 279             //- Return face transformation tensor.
 280             virtual const tensorField& forwardT() const
 281             {
 282                 return forwardT_;
 283             }
 284
 285             //- Return neighbour-cell transformation tensor.
 286             virtual const tensorField& reverseT() const
 287             {
 288                 return reverseT_;
 289             }
 290
 291             //- Are faces collocated. Either size 0,1 or length of patch
 292             virtual const boolList& collocated() const
 293             {
 294                 return collocated_;
 295             }
 296
 297             scalar matchTolerance() const
 298             {
 299                 return matchTolerance_;
 300             }
 301
 302
 303         //- Calculate the patch geometry
 304         virtual void calcGeometry
 305         (
 306             const primitivePatch& referPatch,
 307             const pointField& thisCtrs,
 308             const vectorField& thisAreas,
 309             const pointField& thisCc,
 310             const pointField& nbrCtrs,
 311             const vectorField& nbrAreas,
 312             const pointField& nbrCc
 313         ) = 0;
 314
 315         //- Initialize ordering for primitivePatch. Does not
 316         //  refer to *this (except for name() and type() etc.)
 317         virtual void initOrder
 318         (
 319             PstreamBuffers&,
 320             const primitivePatch&
 321         ) const = 0;
 322
 323         //- Return new ordering for primitivePatch.
 324         //  Ordering is -faceMap: for every face
 325         //  index of the new face -rotation:for every new face the clockwise
 326         //  shift of the original face. Return false if nothing changes
 327         //  (faceMap is identity, rotation is 0), true otherwise.
 328         virtual bool order
 329         (
 330             PstreamBuffers&,
 331             const primitivePatch&,
 332             labelList& faceMap,
 333             labelList& rotation
 334         ) const = 0;
 335
 336         //- Write the polyPatch data as a dictionary
 337         virtual void write(Ostream&) const;
 338 };
 339
 340
 341 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 342
 343 } // End namespace Foam
 344
 345 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 346
 347 #endif
 348
 349 // ************************************************************************* //