applications/utilities/parallelProcessing/decomposePar/domainDecomposition.H

   1 /*---------------------------------------------------------------------------*\
   2   =========                 |
   3   \\      /  F ield         | foam-extend: Open Source CFD
   4    \\    /   O peration     | Version:     3.2
   5     \\  /    A nd           | Web:         http://www.foam-extend.org
   6      \\/     M anipulation  | For copyright notice see file Copyright
   7 -------------------------------------------------------------------------------
   8 License
   9     This file is part of foam-extend.
  10
  11     foam-extend 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 3 of the License, or (at your
  14     option) any later version.
  15
  16     foam-extend is distributed in the hope that it will be useful, but
  17     WITHOUT ANY WARRANTY; without even the implied warranty of
  18     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  19     General Public License for more details.
  20
  21     You should have received a copy of the GNU General Public License
  22     along with foam-extend.  If not, see <http://www.gnu.org/licenses/>.
  23
  24 Class
  25     Foam::domainDecomposition
  26
  27 Description
  28     Automatic domain decomposition class for FOAM meshes
  29
  30 SourceFiles
  31     domainDecomposition.C
  32
  33 \*---------------------------------------------------------------------------*/
  34
  35 #ifndef domainDecomposition_H
  36 #define domainDecomposition_H
  37
  38 #include "fvMesh.H"
  39 #include "labelList.H"
  40 #include "SLList.H"
  41 #include "PtrList.H"
  42 #include "point.H"
  43
  44 #ifndef namespaceFoam
  45 #define namespaceFoam
  46     using namespace Foam;
  47 #endif
  48
  49 /*---------------------------------------------------------------------------*\
  50                      Class domainDecomposition Declaration
  51 \*---------------------------------------------------------------------------*/
  52
  53 class domainDecomposition
  54 :
  55     public fvMesh
  56 {
  57     // Private data
  58
  59         //- Mesh decomposition control dictionary
  60         IOdictionary decompositionDict_;
  61
  62         //- Number of processors in decomposition
  63         label nProcs_;
  64
  65         //- Is the decomposition data to be distributed for each processor
  66         bool distributed_;
  67
  68         //- Processor label for each cell
  69         labelList cellToProc_;
  70
  71         //- Labels of points for each processor
  72         labelListList procPointAddressing_;
  73
  74         //- Labels of faces for each processor
  75         //  Note: Face turning index is stored as the sign on addressing
  76         //  Only the processor boundary faces are affected: if the sign of the
  77         //  index is negative, the processor face is the reverse of the
  78         //  original face. In order to do this properly, all face
  79         //   indices will be incremented by 1 and the decremented as
  80         //  necessary t avoid the problem of face number zero having no
  81         //  sign.  HJ, 5/Dec/2001
  82         labelListList procFaceAddressing_;
  83
  84         //- Number of internal faces for each processor
  85         labelList nInternalProcFaces_;
  86
  87         //- Number of live faces for each processor
  88         labelList nLiveProcFaces_;
  89
  90         //- Labels of cells for each processor
  91         labelListList procCellAddressing_;
  92
  93         //- Original patch index for every processor patch
  94         labelListList procBoundaryAddressing_;
  95
  96         //- Sizes for processor mesh patches
  97         // Excludes inter-processor boundaries
  98         labelListList procPatchSize_;
  99
 100         //- Start indices for processor patches
 101         // Excludes inter-processor boundaries
 102         labelListList procPatchStartIndex_;
 103
 104         //- Neighbour processor ID for inter-processor boundaries
 105         labelListList procNeighbourProcessors_;
 106
 107         //- Sizes for inter-processor patches
 108         labelListList procProcessorPatchSize_;
 109
 110         //- Start indices for inter-processor patches
 111         labelListList procProcessorPatchStartIndex_;
 112
 113         //- List of globally shared point labels
 114         labelList globallySharedPoints_;
 115
 116         //- Are there cyclic-parallel faces
 117         bool cyclicParallel_;
 118
 119
 120     // Private Member Functions
 121
 122         void distributeCells();
 123
 124
 125 public:
 126
 127     // Constructors
 128
 129         //- Construct from IOobject
 130         domainDecomposition(const IOobject& io);
 131
 132
 133     // Destructor
 134
 135         ~domainDecomposition();
 136
 137
 138     // Member Functions
 139
 140         //- Number of processor in decomposition
 141         label nProcs() const
 142         {
 143             return nProcs_;
 144         }
 145
 146         //- Is the decomposition data to be distributed for each processor
 147         bool distributed() const
 148         {
 149             return distributed_;
 150         }
 151
 152         //- Decompose mesh. Optionally remove zero-sized patches.
 153         void decomposeMesh(const bool filterEmptyPatches);
 154
 155         //- Write decomposition
 156         bool writeDecomposition();
 157
 158         //- Cell-processor decomposition labels
 159         const labelList& cellToProc() const
 160         {
 161             return cellToProc_;
 162         }
 163 };
 164
 165
 166 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 167
 168 #endif
 169
 170 // ************************************************************************* //