src/parallel/decompose/decompositionMethods/decompositionMethod/decompositionMethod.H

   1 /*---------------------------------------------------------------------------*\
   2   =========                 |
   3   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
   4    \\    /   O peration     |
   5     \\  /    A nd           | Copyright (C) 2004-2010 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
  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::decompositionMethod
  26
  27 Description
  28     Abstract base class for decomposition
  29
  30 SourceFiles
  31     decompositionMethod.C
  32
  33 \*---------------------------------------------------------------------------*/
  34
  35 #ifndef decompositionMethod_H
  36 #define decompositionMethod_H
  37
  38 #include "polyMesh.H"
  39 #include "pointField.H"
  40 #include "CompactListList.H"
  41
  42 namespace Foam
  43 {
  44
  45 /*---------------------------------------------------------------------------*\
  46                            Class decompositionMethod Declaration
  47 \*---------------------------------------------------------------------------*/
  48
  49 class decompositionMethod
  50 {
  51
  52 protected:
  53
  54     // Protected data
  55
  56         const dictionary& decompositionDict_;
  57         label nProcessors_;
  58
  59
  60         //- Helper: determine (global) cellCells from mesh agglomeration.
  61         static void calcCellCells
  62         (
  63             const polyMesh& mesh,
  64             const labelList& agglom,
  65             const label nCoarse,
  66             CompactListList<label>& cellCells
  67         );
  68
  69         //- Calculate the minimum face between two neighbouring cells
  70         //  (usually there is only one)
  71         static label masterFace(const polyMesh&, const label, const label);
  72
  73 private:
  74
  75     // Private Member Functions
  76
  77         //- Disallow default bitwise copy construct and assignment
  78         decompositionMethod(const decompositionMethod&);
  79         void operator=(const decompositionMethod&);
  80
  81
  82 public:
  83
  84     //- Runtime type information
  85     TypeName("decompositionMethod");
  86
  87
  88     // Declare run-time constructor selection tables
  89
  90         declareRunTimeSelectionTable
  91         (
  92             autoPtr,
  93             decompositionMethod,
  94             dictionary,
  95             (
  96                 const dictionary& decompositionDict
  97             ),
  98             (decompositionDict)
  99         );
 100
 101
 102     // Selectors
 103
 104         //- Return a reference to the selected decomposition method
 105         static autoPtr<decompositionMethod> New
 106         (
 107             const dictionary& decompositionDict
 108         );
 109
 110
 111     // Constructors
 112
 113         //- Construct given the decomposition dictionary
 114         decompositionMethod(const dictionary& decompositionDict)
 115         :
 116             decompositionDict_(decompositionDict),
 117             nProcessors_
 118             (
 119                 readLabel(decompositionDict.lookup("numberOfSubdomains"))
 120             )
 121         {}
 122
 123
 124     //- Destructor
 125     virtual ~decompositionMethod()
 126     {}
 127
 128
 129     // Member Functions
 130
 131         label nDomains() const
 132         {
 133             return nProcessors_;
 134         }
 135
 136         //- Is method parallel aware (i.e. does it synchronize domains across
 137         //  proc boundaries)
 138         virtual bool parallelAware() const = 0;
 139
 140
 141         // No topology (implemented by geometric decomposers)
 142
 143             //- Return for every coordinate the wanted processor number.
 144             virtual labelList decompose
 145             (
 146                 const pointField& points,
 147                 const scalarField& pointWeights
 148             )
 149             {
 150                 notImplemented
 151                 (
 152                     "decompositionMethod:decompose(const pointField&"
 153                     ", const scalarField&)"
 154                 );
 155                 return labelList(0);
 156             }
 157
 158             //- Like decompose but with uniform weights on the points
 159             virtual labelList decompose(const pointField&)
 160             {
 161                 notImplemented
 162                 (
 163                     "decompositionMethod:decompose(const pointField&)"
 164                 );
 165                 return labelList(0);
 166             }
 167
 168
 169         // Topology provided by mesh
 170
 171             //- Return for every coordinate the wanted processor number. Use the
 172             //  mesh connectivity (if needed)
 173             virtual labelList decompose
 174             (
 175                 const polyMesh& mesh,
 176                 const pointField& points,
 177                 const scalarField& pointWeights
 178             ) = 0;
 179
 180             //- Like decompose but with uniform weights on the points
 181             virtual labelList decompose(const polyMesh&, const pointField&);
 182
 183
 184             //- Return for every coordinate the wanted processor number. Gets
 185             //  passed agglomeration map (from fine to coarse cells) and coarse
 186             //  cell
 187             //  location. Can be overridden by decomposers that provide this
 188             //  functionality natively. Coarse cells are local to the processor
 189             //  (if in parallel). If you want to have coarse cells spanning
 190             //  processors use the globalCellCells instead.
 191             virtual labelList decompose
 192             (
 193                 const polyMesh& mesh,
 194                 const labelList& cellToRegion,
 195                 const pointField& regionPoints,
 196                 const scalarField& regionWeights
 197             );
 198
 199             //- Like decompose but with uniform weights on the regions
 200             virtual labelList decompose
 201             (
 202                 const polyMesh& mesh,
 203                 const labelList& cellToRegion,
 204                 const pointField& regionPoints
 205             );
 206
 207
 208         // Topology provided explicitly addressing
 209
 210             //- Return for every coordinate the wanted processor number.
 211             //  The connectivity is equal to mesh.cellCells() except for
 212             //  - in parallel the cell numbers are global cell numbers
 213             //    (starting
 214             //    from 0 at processor0 and then incrementing all through the
 215             //    processors)
 216             //  - the connections are across coupled patches
 217             virtual labelList decompose
 218             (
 219                 const labelListList& globalCellCells,
 220                 const pointField& cc,
 221                 const scalarField& cWeights
 222             ) = 0;
 223
 224             //- Like decompose but with uniform weights on the cells
 225             virtual labelList decompose
 226             (
 227                 const labelListList& globalCellCells,
 228                 const pointField& cc
 229             );
 230
 231 };
 232
 233
 234 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 235
 236 } // End namespace Foam
 237
 238 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 239
 240 #endif
 241
 242 // ************************************************************************* //