applications/utilities/parallelProcessing/decomposePar/fvFieldDecomposer.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::fvFieldDecomposer
  27
  28 Description
  29     Finite Volume volume and surface field decomposer.
  30
  31 SourceFiles
  32     fvFieldDecomposer.C
  33     fvFieldDecomposerDecomposeFields.C
  34
  35 \*---------------------------------------------------------------------------*/
  36
  37 #ifndef fvFieldDecomposer_H
  38 #define fvFieldDecomposer_H
  39
  40 #include "fvMesh.H"
  41 #include "fvPatchFieldMapper.H"
  42 #include "surfaceFields.H"
  43
  44 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
  45
  46 namespace Foam
  47 {
  48
  49 class IOobjectList;
  50
  51 /*---------------------------------------------------------------------------*\
  52                     Class fvFieldDecomposer Declaration
  53 \*---------------------------------------------------------------------------*/
  54
  55 class fvFieldDecomposer
  56 {
  57 public:
  58
  59         //- Patch field decomposer class
  60         class patchFieldDecomposer
  61         :
  62             public fvPatchFieldMapper
  63         {
  64             // Private data
  65
  66                 labelList directAddressing_;
  67
  68         public:
  69
  70             // Constructors
  71
  72                 //- Construct given addressing
  73                 patchFieldDecomposer
  74                 (
  75                     const unallocLabelList& addressingSlice,
  76                     const label addressingOffset
  77                 );
  78
  79
  80             // Member functions
  81
  82                 label size() const
  83                 {
  84                     return directAddressing_.size();
  85                 }
  86
  87                 bool direct() const
  88                 {
  89                     return true;
  90                 }
  91
  92                 const unallocLabelList& directAddressing() const
  93                 {
  94                     return directAddressing_;
  95                 }
  96         };
  97
  98
  99         //- Processor patch field decomposer class. Maps either owner or
 100         //  neighbour data (no interpolate anymore - processorFvPatchField
 101         //  holds neighbour data)
 102         class processorVolPatchFieldDecomposer
 103         :
 104             public fvPatchFieldMapper
 105         {
 106             // Private data
 107
 108                 labelList directAddressing_;
 109
 110         public:
 111
 112             //- Construct given addressing
 113             processorVolPatchFieldDecomposer
 114             (
 115                 const fvMesh& mesh,
 116                 const unallocLabelList& addressingSlice
 117             );
 118
 119
 120             // Member functions
 121
 122                 label size() const
 123                 {
 124                     return directAddressing_.size();
 125                 }
 126
 127                 bool direct() const
 128                 {
 129                     return true;
 130                 }
 131
 132                 const unallocLabelList& directAddressing() const
 133                 {
 134                     return directAddressing_;
 135                 }
 136         };
 137
 138
 139         //- Processor patch field decomposer class. Surface field is assumed
 140         //  to have direction (so manipulates sign when mapping)
 141         class processorSurfacePatchFieldDecomposer
 142         :
 143             public fvPatchFieldMapper
 144         {
 145             labelListList addressing_;
 146             scalarListList weights_;
 147
 148         public:
 149
 150             //- Construct given addressing
 151             processorSurfacePatchFieldDecomposer
 152             (
 153                 const unallocLabelList& addressingSlice
 154             );
 155
 156
 157             // Member functions
 158
 159                 label size() const
 160                 {
 161                     return addressing_.size();
 162                 }
 163
 164                 bool direct() const
 165                 {
 166                     return false;
 167                 }
 168
 169                 const labelListList& addressing() const
 170                 {
 171                     return addressing_;
 172                 }
 173
 174                 const scalarListList& weights() const
 175                 {
 176                     return weights_;
 177                 }
 178         };
 179
 180
 181 private:
 182
 183     // Private data
 184
 185         //- Reference to complete mesh
 186         const fvMesh& completeMesh_;
 187
 188         //- Reference to processor mesh
 189         const fvMesh& procMesh_;
 190
 191         //- Reference to face addressing
 192         const labelList& faceAddressing_;
 193
 194         //- Reference to cell addressing
 195         const labelList& cellAddressing_;
 196
 197         //- Reference to boundary addressing
 198         const labelList& boundaryAddressing_;
 199
 200         //- List of patch field decomposers
 201         List<patchFieldDecomposer*> patchFieldDecomposerPtrs_;
 202
 203         List<processorVolPatchFieldDecomposer*>
 204             processorVolPatchFieldDecomposerPtrs_;
 205
 206         List<processorSurfacePatchFieldDecomposer*>
 207             processorSurfacePatchFieldDecomposerPtrs_;
 208
 209
 210     // Private Member Functions
 211
 212         //- Disallow default bitwise copy construct
 213         fvFieldDecomposer(const fvFieldDecomposer&);
 214
 215         //- Disallow default bitwise assignment
 216         void operator=(const fvFieldDecomposer&);
 217
 218
 219 public:
 220
 221     // Constructors
 222
 223         //- Construct from components
 224         fvFieldDecomposer
 225         (
 226             const fvMesh& completeMesh,
 227             const fvMesh& procMesh,
 228             const labelList& faceAddressing,
 229             const labelList& cellAddressing,
 230             const labelList& boundaryAddressing
 231         );
 232
 233
 234     // Destructor
 235
 236         ~fvFieldDecomposer();
 237
 238
 239     // Member Functions
 240
 241         //- Decompose volume field
 242         template<class Type>
 243         tmp<GeometricField<Type, fvPatchField, volMesh> >
 244         decomposeField
 245         (
 246             const GeometricField<Type, fvPatchField, volMesh>& field
 247         ) const;
 248
 249         //- Decompose surface field
 250         template<class Type>
 251         tmp<GeometricField<Type, fvsPatchField, surfaceMesh> >
 252         decomposeField
 253         (
 254             const GeometricField<Type, fvsPatchField, surfaceMesh>& field
 255         ) const;
 256
 257         template<class GeoField>
 258         void decomposeFields(const PtrList<GeoField>& fields) const;
 259 };
 260
 261
 262 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 263
 264 } // End namespace Foam
 265
 266 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 267
 268 #ifdef NoRepository
 269 #   include "fvFieldDecomposerDecomposeFields.C"
 270 #endif
 271
 272 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 273
 274 #endif
 275
 276 // ************************************************************************* //