src/parallel/decompose/ptscotchDecomp/ptscotchDecomp.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::ptscotchDecomp
  26
  27 Description
  28     PTScotch domain decomposition
  29
  30 SourceFiles
  31     ptscotchDecomp.C
  32
  33 \*---------------------------------------------------------------------------*/
  34
  35 #ifndef ptscotchDecomp_H
  36 #define ptscotchDecomp_H
  37
  38 #include "decompositionMethod.H"
  39
  40 namespace Foam
  41 {
  42
  43 /*---------------------------------------------------------------------------*\
  44                            Class ptscotchDecomp Declaration
  45 \*---------------------------------------------------------------------------*/
  46
  47 class ptscotchDecomp
  48 :
  49     public decompositionMethod
  50 {
  51     // Private Member Functions
  52
  53         //- Insert list in front of list.
  54         template<class Type>
  55         static void prepend(const UList<Type>&, List<Type>&);
  56         //- Insert list at end of list.
  57         template<class Type>
  58         static void append(const UList<Type>&, List<Type>&);
  59
  60         //- Check and print error message
  61         static void check(const int, const char*);
  62
  63         //- Decompose with optionally zero sized domains
  64         label decomposeZeroDomains
  65         (
  66             const fileName& meshPath,
  67             const List<int>& initadjncy,
  68             const List<int>& initxadj,
  69             const scalarField& initcWeights,
  70             List<int>& finalDecomp
  71         ) const;
  72
  73         //- Decompose
  74         label decompose
  75         (
  76             const fileName& meshPath,
  77             const List<int>& adjncy,
  78             const List<int>& xadj,
  79             const scalarField& cWeights,
  80             List<int>& finalDecomp
  81         ) const;
  82
  83         //- Disallow default bitwise copy construct and assignment
  84         void operator=(const ptscotchDecomp&);
  85         ptscotchDecomp(const ptscotchDecomp&);
  86
  87
  88 public:
  89
  90     //- Runtime type information
  91     TypeName("ptscotch");
  92
  93
  94     // Constructors
  95
  96         //- Construct given the decomposition dictionary and mesh
  97         ptscotchDecomp(const dictionary& decompositionDict);
  98
  99
 100     //- Destructor
 101     virtual ~ptscotchDecomp()
 102     {}
 103
 104
 105     // Member Functions
 106
 107         virtual bool parallelAware() const
 108         {
 109             // ptscotch does not know about proc boundaries
 110             return true;
 111         }
 112
 113         //- Return for every coordinate the wanted processor number. Use the
 114         //  mesh connectivity (if needed). See note on weights in scotchDecomp.H
 115         virtual labelList decompose
 116         (
 117             const polyMesh& mesh,
 118             const pointField& points,
 119             const scalarField& pointWeights
 120         );
 121
 122         //- Return for every coordinate the wanted processor number. Gets
 123         //  passed agglomeration map (from fine to coarse cells) and coarse cell
 124         //  location. Can be overridden by decomposers that provide this
 125         //  functionality natively. See note on weights in scotchDecomp.H
 126         virtual labelList decompose
 127         (
 128             const polyMesh& mesh,
 129             const labelList& agglom,
 130             const pointField& regionPoints,
 131             const scalarField& regionWeights
 132         );
 133
 134         //- Return for every coordinate the wanted processor number. Explicitly
 135         //  provided mesh connectivity.
 136         //  The connectivity is equal to mesh.cellCells() except for
 137         //  - in parallel the cell numbers are global cell numbers (starting
 138         //    from 0 at processor0 and then incrementing all through the
 139         //    processors)
 140         //  - the connections are across coupled patches
 141         //  See note on weights in scotchDecomp.H
 142         virtual labelList decompose
 143         (
 144             const labelListList& globalCellCells,
 145             const pointField& cc,
 146             const scalarField& cWeights
 147         );
 148
 149 };
 150
 151
 152 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 153
 154 } // End namespace Foam
 155
 156 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 157
 158 #ifdef NoRepository
 159 #   include "ptscotchDecompTemplates.C"
 160 #endif
 161
 162 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 163
 164 #endif
 165
 166 // ************************************************************************* //