src/meshTools/directMapped/directMappedPolyPatch/directMappedPatchBase.H

   1 /*---------------------------------------------------------------------------*\
   2   =========                 |
   3   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
   4    \\    /   O peration     |
   5     \\  /    A nd           | Copyright (C) 1991-2009 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::directMappedPatchBase
  27
  28 Description
  29     Determines a mapping between patch face centres and mesh cell or face
  30     centres and processors they're on.
  31
  32 Note
  33     Storage is not optimal. It temporary collects all (patch)face centres
  34     on all processors to keep the addressing calculation simple.
  35
  36 SourceFiles
  37     directMappedPatchBase.C
  38
  39 \*---------------------------------------------------------------------------*/
  40
  41 #ifndef directMappedPatchBase_H
  42 #define directMappedPatchBase_H
  43
  44 #include "pointField.H"
  45 #include "Tuple2.H"
  46 #include "pointIndexHit.H"
  47 #include "mapDistribute.H"
  48
  49
  50 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
  51
  52 namespace Foam
  53 {
  54
  55 class polyPatch;
  56 class polyMesh;
  57
  58 /*---------------------------------------------------------------------------*\
  59                       Class directMappedPatchBase Declaration
  60 \*---------------------------------------------------------------------------*/
  61
  62 class directMappedPatchBase
  63 {
  64
  65 public:
  66
  67         //- Mesh items to sample
  68         enum sampleMode
  69         {
  70             NEARESTCELL,
  71             NEARESTPATCHFACE,
  72             NEARESTFACE
  73         };
  74
  75 private:
  76
  77     // Private data
  78
  79         static const NamedEnum<sampleMode, 3> sampleModeNames_;
  80
  81         //- Patch to sample
  82         const polyPatch& patch_;
  83
  84         //- Region to sample
  85         const word sampleRegion_;
  86
  87         //- What to sample
  88         const sampleMode mode_;
  89
  90         //- Patch (only if NEARESTPATCHFACE)
  91         const word samplePatch_;
  92
  93         //- For backwards compatibility : reading/writing of uniform offset.
  94         const bool uniformOffset_;
  95
  96         //- Offset vector (uniform)
  97         const vector offset_;
  98
  99         //- Offset vector
 100         const vectorField offsets_;
 101
 102         //- Same region
 103         const bool sameRegion_;
 104
 105
 106         // Derived information
 107
 108             //- Communication schedule:
 109             //  - Cells/faces to sample per processor
 110             //  - Patch faces to receive per processor
 111             //  - schedule
 112             mutable autoPtr<mapDistribute> mapPtr_;
 113
 114
 115     // Private Member Functions
 116
 117         //- Collect single list of samples and originating processor+face.
 118         void collectSamples
 119         (
 120             pointField&,
 121             labelList& patchFaceProcs,
 122             labelList& patchFaces,
 123             pointField& patchFc
 124         ) const;
 125
 126         //- Find cells/faces containing samples
 127         void findSamples
 128         (
 129             const pointField&,
 130             labelList& sampleProcs,     // processor containing sample
 131             labelList& sampleIndices,   // local index of cell/face
 132             pointField& sampleLocations // actual representative location
 133         ) const;
 134
 135         //- Calculate matching
 136         void calcMapping() const;
 137
 138
 139 public:
 140
 141     //- Runtime type information
 142     TypeName("directMappedPatchBase");
 143
 144
 145     // Constructors
 146
 147         //- Construct from patch
 148         directMappedPatchBase(const polyPatch&);
 149
 150         //- Construct from components
 151         directMappedPatchBase
 152         (
 153             const polyPatch& pp,
 154             const word& sampleRegion,
 155             const sampleMode sampleMode,
 156             const word& samplePatch,
 157             const vectorField& offset
 158         );
 159
 160         //- Construct from components
 161         directMappedPatchBase
 162         (
 163             const polyPatch& pp,
 164             const word& sampleRegion,
 165             const sampleMode sampleMode,
 166             const word& samplePatch,
 167             const vector& offset
 168         );
 169
 170         //- Construct from dictionary
 171         directMappedPatchBase(const polyPatch&, const dictionary&);
 172
 173         //- Construct as copy, resetting patch
 174         directMappedPatchBase(const polyPatch&, const directMappedPatchBase&);
 175
 176
 177     //- Destructor
 178     virtual ~directMappedPatchBase();
 179
 180
 181     // Member functions
 182
 183         void clearOut();
 184
 185         //- What to sample
 186         const sampleMode& mode() const
 187         {
 188             return mode_;
 189         }
 190
 191         //- Region to sample
 192         const word& sampleRegion() const
 193         {
 194             return sampleRegion_;
 195         }
 196
 197         //- Patch (only if NEARESTBOUNDARY)
 198         const word& samplePatch() const
 199         {
 200             return samplePatch_;
 201         }
 202
 203         //- Offset vector (from patch faces to destination mesh objects)
 204         const vectorField& offsets() const
 205         {
 206             return offsets_;
 207         }
 208
 209         //- Return reference to the parallel distribution map
 210         const mapDistribute& map() const
 211         {
 212             if (mapPtr_.empty())
 213             {
 214                 calcMapping();
 215             }
 216             return mapPtr_();
 217         }
 218
 219         //- Cached sampleRegion != mesh.name()
 220         bool sameRegion() const
 221         {
 222             return sameRegion_;
 223         }
 224
 225         //- Get the region mesh
 226         const polyMesh& sampleMesh() const;
 227
 228         //- Get the patch on the region
 229         const polyPatch& samplePolyPatch() const;
 230
 231         //- Write as a dictionary
 232         virtual void write(Ostream&) const;
 233 };
 234
 235
 236 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 237
 238 } // End namespace Foam
 239
 240 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 241
 242 #endif
 243
 244 // ************************************************************************* //