src/OpenFOAM/meshes/polyMesh/polyPatches/constraint/processor/processorPolyPatch.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::processorPolyPatch
  26
  27 Description
  28     Neighbour processor patch.
  29
  30     Note: morph patch face ordering tries to do a geometric ordering.
  31     (assumes faces coincident) Hence will have problems when cyclics
  32     are present.
  33
  34 SourceFiles
  35     processorPolyPatch.C
  36
  37 \*---------------------------------------------------------------------------*/
  38
  39 #ifndef processorPolyPatch_H
  40 #define processorPolyPatch_H
  41
  42 #include "coupledPolyPatch.H"
  43 #include "polyBoundaryMesh.H"
  44 #include "faceListFwd.H"
  45
  46 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
  47
  48 namespace Foam
  49 {
  50
  51 /*---------------------------------------------------------------------------*\
  52                            Class processorPolyPatch Declaration
  53 \*---------------------------------------------------------------------------*/
  54
  55 class processorPolyPatch
  56 :
  57     public coupledPolyPatch
  58 {
  59     // Private data
  60
  61         int myProcNo_;
  62         int neighbProcNo_;
  63
  64         //- Processor-neighbbour patch face centres
  65         vectorField neighbFaceCentres_;
  66
  67         //- Processor-neighbbour patch face areas
  68         vectorField neighbFaceAreas_;
  69
  70         //- Processor-neighbbour patch neighbour cell centres
  71         vectorField neighbFaceCellCentres_;
  72
  73         //- Corresponding neighbouring local point label for every local point
  74         //  (so localPoints()[i] == neighb.localPoints()[neighbPoints_[i]])
  75         mutable autoPtr<labelList> neighbPointsPtr_;
  76
  77         //- Corresponding neighbouring local edge label for every local edge
  78         //  (so edges()[i] == neighb.edges()[neighbEdges_[i]])
  79         mutable autoPtr<labelList> neighbEdgesPtr_;
  80
  81 protected:
  82
  83     // Protected Member functions
  84
  85         //- Initialise the calculation of the patch geometry
  86         void initGeometry(PstreamBuffers&);
  87
  88         //- Calculate the patch geometry
  89         void calcGeometry(PstreamBuffers&);
  90
  91         //- Calculate the patch geometry with externally
  92         //  provided geometry
  93         virtual void calcGeometry
  94         (
  95             const primitivePatch& referPatch,
  96             const pointField& thisCtrs,
  97             const vectorField& thisAreas,
  98             const pointField& thisCc,
  99             const pointField& nbrCtrs,
 100             const vectorField& nbrAreas,
 101             const pointField& nbrCc
 102         )
 103         {
 104             notImplemented("processorPolyPatch::calcGeometry(..)");
 105         }
 106
 107         //- Initialise the patches for moving points
 108         void initMovePoints(PstreamBuffers&, const pointField&);
 109
 110         //- Correct patches after moving points
 111         void movePoints(PstreamBuffers&, const pointField&);
 112
 113         //- Initialise the update of the patch topology
 114         virtual void initUpdateMesh(PstreamBuffers&);
 115
 116         //- Update of the patch topology
 117         virtual void updateMesh(PstreamBuffers&);
 118
 119
 120 public:
 121
 122     //- Runtime type information
 123     TypeName("processor");
 124
 125
 126     // Constructors
 127
 128         //- Construct from components
 129         processorPolyPatch
 130         (
 131             const word& name,
 132             const label size,
 133             const label start,
 134             const label index,
 135             const polyBoundaryMesh& bm,
 136             const int myProcNo,
 137             const int neighbProcNo
 138         );
 139
 140         //- Construct from dictionary
 141         processorPolyPatch
 142         (
 143             const word& name,
 144             const dictionary& dict,
 145             const label index,
 146             const polyBoundaryMesh&
 147         );
 148
 149         //- Construct as copy, resetting the boundary mesh
 150         processorPolyPatch(const processorPolyPatch&, const polyBoundaryMesh&);
 151
 152         //- Construct as given the original patch and resetting the
 153         //  face list and boundary mesh information
 154         processorPolyPatch
 155         (
 156             const processorPolyPatch& pp,
 157             const polyBoundaryMesh& bm,
 158             const label index,
 159             const label newSize,
 160             const label newStart
 161         );
 162
 163         //- Construct given the original patch and a map
 164         processorPolyPatch
 165         (
 166             const processorPolyPatch& pp,
 167             const polyBoundaryMesh& bm,
 168             const label index,
 169             const labelUList& mapAddressing,
 170             const label newStart
 171         );
 172
 173         //- Construct and return a clone, resetting the boundary mesh
 174         virtual autoPtr<polyPatch> clone(const polyBoundaryMesh& bm) const
 175         {
 176             return autoPtr<polyPatch>(new processorPolyPatch(*this, bm));
 177         }
 178
 179         //- Construct and return a clone, resetting the face list
 180         //  and boundary mesh
 181         virtual autoPtr<polyPatch> clone
 182         (
 183             const polyBoundaryMesh& bm,
 184             const label index,
 185             const label newSize,
 186             const label newStart
 187         ) const
 188         {
 189             return autoPtr<polyPatch>
 190             (
 191                 new processorPolyPatch
 192                 (
 193                     *this,
 194                     bm,
 195                     index,
 196                     newSize,
 197                     newStart
 198                 )
 199             );
 200         }
 201
 202         //- Construct and return a clone, resetting the face list
 203         //  and boundary mesh
 204         virtual autoPtr<polyPatch> clone
 205         (
 206             const polyBoundaryMesh& bm,
 207             const label index,
 208             const labelUList& mapAddressing,
 209             const label newStart
 210         ) const
 211         {
 212             return autoPtr<polyPatch>
 213             (
 214                 new processorPolyPatch
 215                 (
 216                     *this,
 217                     bm,
 218                     index,
 219                     mapAddressing,
 220                     newStart
 221                 )
 222             );
 223         }
 224
 225
 226     //- Destructor
 227     virtual ~processorPolyPatch();
 228
 229
 230     // Member functions
 231
 232         //- Return true only if this is a parallel run
 233         virtual bool coupled() const
 234         {
 235             if (Pstream::parRun())
 236             {
 237                 return true;
 238             }
 239             else
 240             {
 241                 return false;
 242             }
 243         }
 244
 245         //- Return processor number
 246         int myProcNo() const
 247         {
 248             return myProcNo_;
 249         }
 250
 251         //- Return neigbour processor number
 252         int neighbProcNo() const
 253         {
 254             return neighbProcNo_;
 255         }
 256
 257         //- Does the processor own the patch ?
 258         virtual bool owner() const
 259         {
 260             return (myProcNo_ < neighbProcNo_);
 261         }
 262
 263         //- Is the processor the patch neighbour ?
 264         bool neighbour() const
 265         {
 266             return !owner();
 267         }
 268
 269         //- Return processor-neighbbour patch face centres
 270         const vectorField& neighbFaceCentres() const
 271         {
 272             return neighbFaceCentres_;
 273         }
 274
 275         //- Return processor-neighbbour patch face areas
 276         const vectorField& neighbFaceAreas() const
 277         {
 278             return neighbFaceAreas_;
 279         }
 280
 281         //- Return processor-neighbbour patch neighbour cell centres
 282         const vectorField& neighbFaceCellCentres() const
 283         {
 284             return neighbFaceCellCentres_;
 285         }
 286
 287         //- Return neighbour point labels. WIP.
 288         const labelList& neighbPoints() const;
 289
 290         //- Return neighbour edge labels. WIP.
 291         const labelList& neighbEdges() const;
 292
 293         //- Return message tag to use for communication
 294         virtual int tag() const
 295         {
 296             return Pstream::msgType();
 297         }
 298
 299         //- Transform a patch-based position from other side to this side
 300         virtual void transformPosition(pointField& l) const
 301         {}
 302
 303         //- Transform a patch-based position from other side to this side
 304         virtual void transformPosition(point&, const label facei) const
 305         {}
 306
 307         //- Initialize ordering for primitivePatch. Does not
 308         //  refer to *this (except for name() and type() etc.)
 309         virtual void initOrder(PstreamBuffers&, const primitivePatch&) const;
 310
 311         //- Return new ordering for primitivePatch.
 312         //  Ordering is -faceMap: for every face
 313         //  index of the new face -rotation:for every new face the clockwise
 314         //  shift of the original face. Return false if nothing changes
 315         //  (faceMap is identity, rotation is 0), true otherwise.
 316         virtual bool order
 317         (
 318             PstreamBuffers&,
 319             const primitivePatch&,
 320             labelList& faceMap,
 321             labelList& rotation
 322         ) const;
 323
 324
 325         //- Write the polyPatch data as a dictionary
 326         virtual void write(Ostream&) const;
 327 };
 328
 329
 330 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 331
 332 } // End namespace Foam
 333
 334 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 335
 336 #endif
 337
 338 // ************************************************************************* //