applications/utilities/parallelProcessing/decomposePar/faFieldDecomposer.H

   1 /*---------------------------------------------------------------------------*\
   2   =========                 |
   3   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
   4    \\    /   O peration     |
   5     \\  /    A nd           | Copyright held by original author
   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     faFieldDecomposer
  27
  28 Description
  29     Finite Area area and edge field decomposer.
  30
  31 Author
  32     Zeljko Tukovic, FSB Zagreb.  All rights reserved
  33
  34 SourceFiles
  35     faFieldDecomposer.C
  36     faFieldDecomposerDecomposeFields.C
  37
  38 \*---------------------------------------------------------------------------*/
  39
  40 #ifndef faFieldDecomposer_H
  41 #define faFieldDecomposer_H
  42
  43 // #include "faMesh.H"
  44 // #include "faPatchFieldMapper.H"
  45 #include "faMesh.H"
  46 #include "faPatchFieldMapper.H"
  47 #include "edgeFields.H"
  48
  49 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
  50
  51 namespace Foam
  52 {
  53
  54 class IOobjectList;
  55
  56 /*---------------------------------------------------------------------------*\
  57                     Class faFieldDecomposer Declaration
  58 \*---------------------------------------------------------------------------*/
  59
  60 class faFieldDecomposer
  61 {
  62 public:
  63
  64         //- Patch field decomposer class
  65         class patchFieldDecomposer
  66         :
  67             public faPatchFieldMapper
  68         {
  69             // Private data
  70
  71                 label sizeBeforeMapping_;
  72                 labelList directAddressing_;
  73
  74         public:
  75
  76             // Constructors
  77
  78                 //- Construct given addressing
  79                 patchFieldDecomposer
  80                 (
  81                     const label sizeBeforeMapping,
  82                     const unallocLabelList& addressingSlice,
  83                     const label addressingOffset
  84                 );
  85
  86
  87             // Member functions
  88
  89                 label size() const
  90                 {
  91                     return directAddressing_.size();
  92                 }
  93
  94                 virtual label sizeBeforeMapping() const
  95                 {
  96                     return sizeBeforeMapping_;
  97                 }
  98
  99                 bool direct() const
 100                 {
 101                     return true;
 102                 }
 103
 104                 const unallocLabelList& directAddressing() const
 105                 {
 106                     return directAddressing_;
 107                 }
 108         };
 109
 110
 111         //- Processor patch field decomposer class
 112         class processorAreaPatchFieldDecomposer
 113         :
 114             public faPatchFieldMapper
 115         {
 116             // Private data
 117
 118                 label sizeBeforeMapping_;
 119                 labelListList addressing_;
 120                 scalarListList weights_;
 121
 122         public:
 123
 124             //- Construct given addressing
 125             processorAreaPatchFieldDecomposer
 126             (
 127                 const faMesh& mesh,
 128                 const unallocLabelList& addressingSlice
 129             );
 130
 131
 132             // Member functions
 133
 134                 label size() const
 135                 {
 136                     return addressing_.size();
 137                 }
 138
 139                 virtual label sizeBeforeMapping() const
 140                 {
 141                     return sizeBeforeMapping_;
 142                 }
 143
 144                 bool direct() const
 145                 {
 146                     return false;
 147                 }
 148
 149                 const labelListList& addressing() const
 150                 {
 151                     return addressing_;
 152                 }
 153
 154                 const scalarListList& weights() const
 155                 {
 156                     return weights_;
 157                 }
 158         };
 159
 160
 161         //- Processor patch field decomposer class
 162         class processorEdgePatchFieldDecomposer
 163         :
 164             public faPatchFieldMapper
 165         {
 166             label sizeBeforeMapping_;
 167             labelListList addressing_;
 168             scalarListList weights_;
 169
 170         public:
 171
 172             //- Construct given addressing
 173             processorEdgePatchFieldDecomposer
 174             (
 175                 label sizeBeforeMapping,
 176                 const unallocLabelList& addressingSlice
 177             );
 178
 179
 180             // Member functions
 181
 182                 label size() const
 183                 {
 184                     return addressing_.size();
 185                 }
 186
 187                 virtual label sizeBeforeMapping() const
 188                 {
 189                     return sizeBeforeMapping_;
 190                 }
 191
 192                 bool direct() const
 193                 {
 194                     return false;
 195                 }
 196
 197                 const labelListList& addressing() const
 198                 {
 199                     return addressing_;
 200                 }
 201
 202                 const scalarListList& weights() const
 203                 {
 204                     return weights_;
 205                 }
 206         };
 207
 208
 209 private:
 210
 211     // Private data
 212
 213         //- Reference to complete mesh
 214         const faMesh& completeMesh_;
 215
 216         //- Reference to processor mesh
 217         const faMesh& procMesh_;
 218
 219         //- Reference to edge addressing
 220         const labelList& edgeAddressing_;
 221
 222         //- Reference to face addressing
 223         const labelList& faceAddressing_;
 224
 225         //- Reference to boundary addressing
 226         const labelList& boundaryAddressing_;
 227
 228         //- List of patch field decomposers
 229         List<patchFieldDecomposer*> patchFieldDecomposerPtrs_;
 230
 231         List<processorAreaPatchFieldDecomposer*>
 232             processorAreaPatchFieldDecomposerPtrs_;
 233
 234         List<processorEdgePatchFieldDecomposer*>
 235             processorEdgePatchFieldDecomposerPtrs_;
 236
 237
 238     // Private Member Functions
 239
 240         //- Disallow default bitwise copy construct
 241         faFieldDecomposer(const faFieldDecomposer&);
 242
 243         //- Disallow default bitwise assignment
 244         void operator=(const faFieldDecomposer&);
 245
 246
 247 public:
 248
 249     // Constructors
 250
 251         //- Construct from components
 252         faFieldDecomposer
 253         (
 254             const faMesh& completeMesh,
 255             const faMesh& procMesh,
 256             const labelList& edgeAddressing,
 257             const labelList& faceAddressing,
 258             const labelList& boundaryAddressing
 259         );
 260
 261
 262     // Destructor
 263
 264         ~faFieldDecomposer();
 265
 266
 267     // Member Functions
 268
 269         //- Decompose area field
 270         template<class Type>
 271         tmp<GeometricField<Type, faPatchField, areaMesh> >
 272         decomposeField
 273         (
 274             const GeometricField<Type, faPatchField, areaMesh>& field
 275         ) const;
 276
 277         //- Decompose surface field
 278         template<class Type>
 279         tmp<GeometricField<Type, faePatchField, edgeMesh> >
 280         decomposeField
 281         (
 282             const GeometricField<Type, faePatchField, edgeMesh>& field
 283         ) const;
 284
 285         template<class GeoField>
 286         void decomposeFields(const PtrList<GeoField>& fields) const;
 287 };
 288
 289
 290 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 291
 292 } // End namespace Foam
 293
 294 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 295
 296 #ifdef NoRepository
 297 #   include "faFieldDecomposerDecomposeFields.C"
 298 #endif
 299
 300 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 301
 302 #endif
 303
 304 // ************************************************************************* //