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) 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::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         //- 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         );
 168
 169
 170 public:
 171
 172     //- Runtime type information
 173     TypeName("coupled");
 174
 175
 176     // Constructors
 177
 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         );
 187
 188         //- Construct from dictionary
 189         coupledPolyPatch
 190         (
 191             const word& name,
 192             const dictionary& dict,
 193             const label index,
 194             const polyBoundaryMesh& bm
 195         );
 196
 197         //- Construct as copy, resetting the boundary mesh
 198         coupledPolyPatch(const coupledPolyPatch&, const polyBoundaryMesh&);
 199
 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         );
 210
 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         );
 220
 221
 222     //- Destructor
 223     virtual ~coupledPolyPatch();
 224
 225
 226     // Member Functions
 227
 228         // Access
 229
 230             //- Return true because this patch is coupled
 231             virtual bool coupled() const
 232             {
 233                 return true;
 234             }
 235
 236             //- Does this side own the patch ?
 237             virtual bool owner() const = 0;
 238
 239             //- Does the coupled side own the patch ?
 240             virtual bool neighbour() const
 241             {
 242                 return !owner();
 243             }
 244
 245             //- Transform a patch-based position from other side to this side
 246             virtual void transformPosition(pointField&) const = 0;
 247
 248             //- Transform a patch-based position from other side to this side
 249             virtual void transformPosition(point&, const label facei) const = 0;
 250
 251             //- Are the planes separated.
 252             virtual bool separated() const
 253             {
 254                 return separation_.size();
 255             }
 256
 257             //- If the planes are separated the separation vector.
 258             virtual const vectorField& separation() const
 259             {
 260                 return separation_;
 261             }
 262
 263             //- Are the cyclic planes parallel.
 264             virtual bool parallel() const
 265             {
 266                 return forwardT_.empty();
 267             }
 268
 269             //- Return face transformation tensor.
 270             virtual const tensorField& forwardT() const
 271             {
 272                 return forwardT_;
 273             }
 274
 275             //- Return neighbour-cell transformation tensor.
 276             virtual const tensorField& reverseT() const
 277             {
 278                 return reverseT_;
 279             }
 280
 281             //- Are faces collocated. Either size 0,1 or length of patch
 282             virtual const boolList& collocated() const
 283             {
 284                 return collocated_;
 285             }
 286
 287             scalar matchTolerance() const
 288             {
 289                 return matchTolerance_;
 290             }
 291
 292
 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;
 304
 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;
 312
 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;
 325
 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         );
 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 // ************************************************************************* //