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 NEARESTBOUNDARY)
  91         const word samplePatch_;
  92
  93         //- Offset vector
  94         const vector offset_;
  95
  96         //- Same region
  97         const bool sameRegion_;
  98
  99
 100         // Derived information
 101
 102             //- Communication schedule:
 103             //  - Cells/faces to sample per processor
 104             //  - Patch faces to receive per processor
 105             //  - schedule
 106             mutable autoPtr<mapDistribute> mapPtr_;
 107
 108
 109     // Private Member Functions
 110
 111         //- Collect single list of samples and originating processor+face.
 112         void collectSamples
 113         (
 114             pointField&,
 115             labelList& patchFaceProcs,
 116             labelList& patchFaces,
 117             pointField& patchFc
 118         ) const;
 119
 120         //- Find cells/faces containing samples
 121         void findSamples
 122         (
 123             const pointField&,
 124             labelList& sampleProcs,     // processor containing sample
 125             labelList& sampleIndices,   // local index of cell/face
 126             pointField& sampleLocations // actual representative location
 127         ) const;
 128
 129         //- Calculate matching
 130         void calcMapping() const;
 131
 132
 133     // Private class
 134
 135         //- Private class for finding nearest
 136         //  - point+local index
 137         //  - sqr(distance)
 138         //  - processor
 139         typedef Tuple2<pointIndexHit, Tuple2<scalar, label> > nearInfo;
 140
 141         class nearestEqOp
 142         {
 143
 144         public:
 145
 146             void operator()(nearInfo& x, const nearInfo& y) const
 147             {
 148                 if (y.first().hit())
 149                 {
 150                     if (!x.first().hit())
 151                     {
 152                         x = y;
 153                     }
 154                     else if (y.second().first() < x.second().first())
 155                     {
 156                         x = y;
 157                     }
 158                 }
 159             }
 160         };
 161
 162
 163 public:
 164
 165     //- Runtime type information
 166     TypeName("directMappedPatchBase");
 167
 168
 169     // Constructors
 170
 171         //- Construct from components
 172         directMappedPatchBase(const polyPatch&);
 173
 174         //- Construct from dictionary
 175         directMappedPatchBase(const polyPatch&, const dictionary&);
 176
 177         //- Construct as copy, resetting patch
 178         directMappedPatchBase(const polyPatch&, const directMappedPatchBase&);
 179
 180
 181     //- Destructor
 182     virtual ~directMappedPatchBase();
 183
 184
 185     // Member functions
 186
 187         void clearOut();
 188
 189         //- What to sample
 190         const sampleMode& mode() const
 191         {
 192             return mode_;
 193         }
 194
 195         //- Region to sample
 196         const word& sampleRegion() const
 197         {
 198             return sampleRegion_;
 199         }
 200
 201         //- Patch (only if NEARESTBOUNDARY)
 202         const word& samplePatch() const
 203         {
 204             return samplePatch_;
 205         }
 206
 207         //- Offset vector (from patch faces to destination mesh objects)
 208         const vector& offset() const
 209         {
 210             return offset_;
 211         }
 212
 213         //- Return reference to the parallel distribution map
 214         const mapDistribute& map() const
 215         {
 216             if (mapPtr_.empty())
 217             {
 218                 calcMapping();
 219             }
 220             return mapPtr_();
 221         }
 222
 223         //- Cached sampleRegion != mesh.name()
 224         bool sameRegion() const
 225         {
 226             return sameRegion_;
 227         }
 228
 229         //- Get the region mesh
 230         const polyMesh& sampleMesh() const;
 231
 232         //- Get the patch on the region
 233         const polyPatch& samplePolyPatch() const;
 234
 235         //- Write as a dictionary
 236         virtual void write(Ostream&) const;
 237 };
 238
 239
 240 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 241
 242 } // End namespace Foam
 243
 244 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 245
 246 #endif
 247
 248 // ************************************************************************* //