src/OpenFOAM/meshes/polyMesh/mapPolyMesh/mapDistribute/mapDistribute.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::mapDistribute
  27
  28 Description
  29     Class containing processor-to-processor mapping information.
  30
  31     We store mapping from the bits-to-send to the complete starting list
  32     (subXXXMap) and from the received bits to their location in the new
  33     list (constructXXXMap).
  34
  35 Note:
  36     Schedule is a list of processor pairs (one send, one receive. One of
  37     them will be myself) which forms a scheduled (i.e. non-buffered) exchange.
  38     See distribute on how to use it.
  39     Note2: number of items send on one processor have to equal the number
  40     of items received on the other processor.
  41
  42
  43 SourceFiles
  44     mapDistribute.C
  45
  46 \*---------------------------------------------------------------------------*/
  47
  48 #ifndef mapDistribute_H
  49 #define mapDistribute_H
  50
  51 #include "labelList.H"
  52 #include "labelPair.H"
  53 #include "Pstream.H"
  54 #include "boolList.H"
  55
  56 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
  57
  58 namespace Foam
  59 {
  60
  61 class mapPolyMesh;
  62
  63 /*---------------------------------------------------------------------------*\
  64                            Class mapDistribute Declaration
  65 \*---------------------------------------------------------------------------*/
  66
  67 class mapDistribute
  68 {
  69     // Private data
  70
  71         //- Size of reconstructed data
  72         label constructSize_;
  73
  74         //- Maps from subsetted data back to original data
  75         labelListList subMap_;
  76
  77         //- Maps from subsetted data to new reconstructed data
  78         labelListList constructMap_;
  79
  80         //- Schedule
  81         mutable autoPtr<List<labelPair> > schedulePtr_;
  82
  83
  84 public:
  85
  86     // Constructors
  87
  88         //- Construct from components
  89         mapDistribute
  90         (
  91             const label constructSize,
  92             const labelListList& subMap,
  93             const labelListList& constructMap
  94         );
  95
  96         //- (optionally destructively) construct from components
  97         mapDistribute
  98         (
  99             const label constructSize,
 100             labelListList& subMap,
 101             labelListList& constructMap,
 102             const bool reUse                // clone or reuse
 103         );
 104
 105         //- Construct from reverse addressing: per data item the send
 106         //  processor and the receive processor. All processors get same data.
 107         mapDistribute
 108         (
 109             const labelList& sendProcs,
 110             const labelList& recvProcs
 111         );
 112
 113         //- Construct copy
 114         mapDistribute(const mapDistribute&);
 115
 116
 117     // Member Functions
 118
 119         // Access
 120
 121             //- Constructed data size
 122             label constructSize() const
 123             {
 124                 return constructSize_;
 125             }
 126
 127             //- Constructed data size
 128             label& constructSize()
 129             {
 130                 return constructSize_;
 131             }
 132
 133             //- From subsetted data back to original data
 134             const labelListList& subMap() const
 135             {
 136                 return subMap_;
 137             }
 138
 139             //- From subsetted data back to original data
 140             labelListList& subMap()
 141             {
 142                 return subMap_;
 143             }
 144
 145             //- From subsetted data to new reconstructed data
 146             const labelListList& constructMap() const
 147             {
 148                 return constructMap_;
 149             }
 150
 151             //- From subsetted data to new reconstructed data
 152             labelListList& constructMap()
 153             {
 154                 return constructMap_;
 155             }
 156
 157             //- Calculate a schedule. See above.
 158             static List<labelPair> schedule
 159             (
 160                 const labelListList& subMap,
 161                 const labelListList& constructMap
 162             );
 163
 164             //- Return a schedule. Demand driven. See above.
 165             const List<labelPair>& schedule() const;
 166
 167
 168         // Other
 169
 170             //- Compact maps. Gets per field a bool whether it is used (locally)
 171             //  and works out itself what this side and sender side can remove
 172             //  from maps.
 173             void compact(const boolList& elemIsUsed);
 174
 175
 176             //- Distribute data. Note:schedule only used for Pstream::scheduled
 177             //  for now, all others just use send-to-all, receive-from-all.
 178             template<class T>
 179             static void distribute
 180             (
 181                 const Pstream::commsTypes commsType,
 182                 const List<labelPair>& schedule,
 183                 const label constructSize,
 184                 const labelListList& subMap,
 185                 const labelListList& constructMap,
 186                 List<T>&
 187             );
 188
 189             //- Distribute data. If multiple processors writing to same
 190             //  position adds contributions using cop.
 191             template<class T, class CombineOp>
 192             static void distribute
 193             (
 194                 const Pstream::commsTypes commsType,
 195                 const List<labelPair>& schedule,
 196                 const label constructSize,
 197                 const labelListList& subMap,
 198                 const labelListList& constructMap,
 199                 List<T>&,
 200                 const CombineOp& cop,
 201                 const T& nullValue
 202             );
 203
 204             //- Distribute data using default commsType.
 205             template<class T>
 206             void distribute(List<T>& fld) const
 207             {
 208                 if
 209                 (
 210                     Pstream::defaultCommsType == Pstream::nonBlocking
 211                  && contiguous<T>()
 212                 )
 213                 {
 214                     distribute
 215                     (
 216                         Pstream::nonBlocking,
 217                         List<labelPair>(),
 218                         constructSize_,
 219                         subMap_,
 220                         constructMap_,
 221                         fld
 222                     );
 223                 }
 224                 else if (Pstream::defaultCommsType == Pstream::scheduled)
 225                 {
 226                     distribute
 227                     (
 228                         Pstream::scheduled,
 229                         schedule(),
 230                         constructSize_,
 231                         subMap_,
 232                         constructMap_,
 233                         fld
 234                     );
 235                 }
 236                 else
 237                 {
 238                     distribute
 239                     (
 240                         Pstream::blocking,
 241                         List<labelPair>(),
 242                         constructSize_,
 243                         subMap_,
 244                         constructMap_,
 245                         fld
 246                     );
 247                 }
 248             }
 249
 250             //- Correct for topo change.
 251             void updateMesh(const mapPolyMesh&)
 252             {
 253                 notImplemented
 254                 (
 255                     "mapDistribute::updateMesh(const mapPolyMesh&)"
 256                 );
 257             }
 258
 259     // Member Operators
 260
 261         void operator=(const mapDistribute&);
 262
 263 };
 264
 265
 266 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 267
 268 } // End namespace Foam
 269
 270 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 271
 272 #ifdef NoRepository
 273 #   include "mapDistributeTemplates.C"
 274 #endif
 275
 276 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 277
 278 #endif
 279
 280 // ************************************************************************* //