src/foam/meshes/polyMesh/polyPatches/constraint/overlapGgi/overlapGgiPolyPatch.H

   1 /*---------------------------------------------------------------------------*\
   2   =========                 |
   3   \\      /  F ield         | foam-extend: Open Source CFD
   4    \\    /   O peration     | Version:     3.2
   5     \\  /    A nd           | Web:         http://www.foam-extend.org
   6      \\/     M anipulation  | For copyright notice see file Copyright
   7 -------------------------------------------------------------------------------
   8 License
   9     This file is part of foam-extend.
  10
  11     foam-extend 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 3 of the License, or (at your
  14     option) any later version.
  15
  16     foam-extend is distributed in the hope that it will be useful, but
  17     WITHOUT ANY WARRANTY; without even the implied warranty of
  18     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  19     General Public License for more details.
  20
  21     You should have received a copy of the GNU General Public License
  22     along with foam-extend.  If not, see <http://www.gnu.org/licenses/>.
  23
  24 Class
  25     overlapGgiPolyPatch
  26
  27 Description
  28     Partial overlap generalised grid interface (GGI) patch. Master and slave
  29     sides are copied as much as the given number to complete the 360 degree
  30     cicumferential surface.
  31
  32     The data interpolation between master and slave patches do not depend on
  33     relative position of them, because of the full circumferential expansion
  34     for both sides.
  35
  36 Author
  37     Hrvoje Jasak, Wikki Ltd.  All rights reserved
  38     Fethi Tekin, All rights reserved.
  39     Oliver Borm, All rights reserved.
  40
  41 SourceFiles
  42     overlapGgiPolyPatch.C
  43     overlapGgiPolyPatchGeometry.C
  44
  45 \*---------------------------------------------------------------------------*/
  46
  47 #ifndef overlapGgiPolyPatch_H
  48 #define overlapGgiPolyPatch_H
  49
  50 #include "coupledPolyPatch.H"
  51 #include "standAlonePatch.H"
  52 #include "overlapGgiInterpolation.H"
  53 #include "faceZone.H"
  54
  55 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
  56
  57 namespace Foam
  58 {
  59
  60 /*---------------------------------------------------------------------------*\
  61                      Class overlapGgiPolyPatch Declaration
  62 \*---------------------------------------------------------------------------*/
  63
  64 class overlapGgiPolyPatch
  65 :
  66     public coupledPolyPatch
  67 {
  68     // Private data
  69
  70         //- Shadow patch name
  71         const word shadowName_;
  72
  73         //- Interpolation zone name
  74         const word zoneName_;
  75
  76         //- Shadow patch index.  Delayed evaluation for construction
  77         mutable label shadowIndex_;
  78
  79         //- Interpolation zone index.  Delayed evaluation for construction
  80         mutable label zoneIndex_;
  81
  82         //- Rotation parameter for the overlap
  83
  84             //- Rotation axis
  85             const vector rotationAxis_;
  86
  87             // Number of copies in order to complete 360 degrees
  88             const label nCopies_;
  89
  90
  91         // Interpolation
  92
  93             //- Pointer to expanded master patch
  94             mutable standAlonePatch* expandedMasterPtr_;
  95
  96             //- Pointer to expanded slave patch
  97             mutable standAlonePatch* expandedSlavePtr_;
  98
  99             //- Patch-to-expanded-patch interpolation
 100             mutable overlapGgiInterpolation* patchToPatchPtr_;
 101
 102             //- Is the patch localised on a single processor
 103             // (single processor in a parallel run)?
 104             //  Used for parallel optimisation
 105             mutable bool* localParallelPtr_;
 106
 107             //- Reconstructed patch neighbour cell centres
 108             mutable vectorField* reconFaceCellCentresPtr_;
 109
 110
 111     // Private member functions
 112
 113         //- Return reference to patch-to-patch interpolation
 114         const overlapGgiInterpolation& patchToPatch() const;
 115
 116         //- Calculate expanded patch geometry
 117         standAlonePatch* calcExpandedGeometry(label ncp, label index) const;
 118
 119         //- Return reference to expanded master patch
 120         const standAlonePatch& expandedMaster() const;
 121
 122         //- Return reference to expanded slave patch
 123         const standAlonePatch& expandedSlave() const;
 124
 125         //- Calculate local parallel switch
 126         void calcLocalParallel() const;
 127
 128         //- Calculate interpolation
 129         void calcPatchToPatch() const;
 130
 131         //- Calculate reconstructed cell centres
 132         void calcReconFaceCellCentres() const;
 133
 134         //- Force calculation of transformation tensors
 135         void calcTransforms() const;
 136
 137         //- Check definition: angles and offsets
 138         void checkDefinition() const;
 139
 140         //- Clear geometry
 141         void clearGeom();
 142
 143         //- Clear out
 144         void clearOut();
 145
 146
 147 protected:
 148
 149     // Protected Member functions
 150
 151         //- Is the GGI active? (zone and shadow present)
 152         bool active() const;
 153
 154         //- Initialise the calculation of the patch addressing
 155         virtual void initAddressing();
 156
 157         //- Calculate the patch addressing
 158         virtual void calcAddressing();
 159
 160         //- Initialise the calculation of the patch geometry
 161         virtual void initGeometry();
 162
 163         //- Calculate the patch geometry
 164         virtual void calcGeometry();
 165
 166         //- Initialise the patches for moving points
 167         virtual void initMovePoints(const pointField&);
 168
 169         //- Correct patches after moving points
 170         virtual void movePoints(const pointField&);
 171
 172         //- Initialise the update of the patch topology
 173         virtual void initUpdateMesh();
 174
 175         //- Update of the patch topology
 176         virtual void updateMesh();
 177
 178
 179 public:
 180
 181     //- Runtime type information
 182     TypeName("overlapGgi");
 183
 184
 185     // Constructors
 186
 187         //- Construct from components
 188         overlapGgiPolyPatch
 189         (
 190             const word& name,
 191             const label size,
 192             const label start,
 193             const label index,
 194             const polyBoundaryMesh& bm
 195         );
 196
 197         //- Construct from components
 198         overlapGgiPolyPatch
 199         (
 200             const word& name,
 201             const label size,
 202             const label start,
 203             const label index,
 204             const polyBoundaryMesh& bm,
 205             const word& shadowName,
 206             const word& zoneName,
 207             const vector& axis,
 208             const scalar nCopies
 209         );
 210
 211         //- Construct from dictionary
 212         overlapGgiPolyPatch
 213         (
 214             const word& name,
 215             const dictionary& dict,
 216             const label index,
 217             const polyBoundaryMesh&
 218         );
 219
 220         //- Construct as copy, resetting the boundary mesh
 221         overlapGgiPolyPatch
 222         (
 223             const overlapGgiPolyPatch&,
 224             const polyBoundaryMesh&
 225         );
 226
 227         //- Construct as given the original patch and resetting the
 228         //  face list and boundary mesh information
 229         overlapGgiPolyPatch
 230         (
 231             const overlapGgiPolyPatch& pp,
 232             const polyBoundaryMesh& bm,
 233             const label index,
 234             const label newSize,
 235             const label newStart
 236         );
 237
 238         //- Construct and return a clone, resetting the boundary mesh
 239         virtual autoPtr<polyPatch> clone(const polyBoundaryMesh& bm) const
 240         {
 241             return autoPtr<polyPatch>(new overlapGgiPolyPatch(*this, bm));
 242         }
 243
 244         //- Construct and return a clone, resetting the face list
 245         //  and boundary mesh
 246         virtual autoPtr<polyPatch> clone
 247         (
 248             const polyBoundaryMesh& bm,
 249             const label index,
 250             const label newSize,
 251             const label newStart
 252         ) const
 253         {
 254             return autoPtr<polyPatch>
 255             (
 256                 new overlapGgiPolyPatch
 257                 (
 258                     refCast<const overlapGgiPolyPatch>(*this),
 259                     bm,
 260                     index,
 261                     newSize,
 262                     newStart
 263                 )
 264             );
 265         }
 266
 267
 268     // Destructor
 269
 270         virtual ~overlapGgiPolyPatch();
 271
 272
 273     // Member functions
 274
 275         //- Return shadow patch name
 276         const word& shadowName() const
 277         {
 278             return shadowName_;
 279         }
 280
 281         //- Return name of interpolation face zone
 282         const word& zoneName() const
 283         {
 284             return zoneName_;
 285         }
 286
 287         //- Return shadow patch index
 288         label shadowIndex() const;
 289
 290         //- Return zone patch index
 291         label zoneIndex() const;
 292
 293         //- Return shadow patch
 294         const overlapGgiPolyPatch& shadow() const;
 295
 296         //- Return interpolation face zone
 297         const faceZone& zone() const;
 298
 299         //- Return rotation axis
 300         const vector& rotationAxis() const
 301         {
 302             return rotationAxis_;
 303         }
 304
 305         //- Return wedge angle
 306         scalar angle() const
 307         {
 308             return 360.0/scalar(nCopies());
 309         }
 310
 311         //- Return number of slave copies
 312         const label& nCopies() const;
 313
 314         //- Is this the master side?
 315         bool master() const;
 316
 317         //- Is this the slave side?
 318         bool slave() const
 319         {
 320             return !master();
 321         }
 322
 323         //- Is the patch localised on a single processor
 324         bool localParallel() const;
 325
 326         //- Expand face field to full for 360 degrees coverage
 327         template<class Type>
 328         tmp<Field<Type> > expandData(const Field<Type>& spf) const;
 329
 330         //- Interpolate face field: given field on the shadow side,
 331         //  create an interpolated field on this side
 332         template<class Type>
 333         tmp<Field<Type> > interpolate(const Field<Type>& pf) const;
 334
 335         template<class Type>
 336         tmp<Field<Type> > interpolate(const tmp<Field<Type> >& tpf) const;
 337
 338         //- Filter zone field to patch size
 339         template<class Type>
 340         tmp<Field<Type> > filter(const Field<Type>& zf) const;
 341
 342         //- Return reconstructed cell centres
 343         const vectorField& reconFaceCellCentres() const;
 344
 345         //- Initialize ordering for primitivePatch. Does not
 346         //  refer to *this (except for name() and type() etc.)
 347         virtual void initOrder(const primitivePatch&) const;
 348
 349         //- Return new ordering for primitivePatch.
 350         //  Ordering is -faceMap: for every face
 351         //  index of the new face -rotation: for every new face the clockwise
 352         //  shift of the original face. Return false if nothing changes
 353         //  (faceMap is identity, rotation is 0), true otherwise.
 354         virtual bool order
 355         (
 356             const primitivePatch&,
 357             labelList& faceMap,
 358             labelList& rotation
 359         ) const;
 360
 361         //- Synchronise communications of ordering for primitivePatch
 362         //  Used in cases when no topological change happens locally,
 363         //  but is happening on other processors
 364         virtual void syncOrder() const;
 365
 366
 367         //- Write
 368         virtual void write(Ostream&) const;
 369 };
 370
 371
 372 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 373
 374 } // End namespace Foam
 375
 376 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 377
 378 #ifdef NoRepository
 379 #   include "overlapGgiPolyPatchTemplates.C"
 380 #endif
 381
 382 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 383
 384 #endif
 385
 386 // ************************************************************************* //