src/OpenFOAM/matrices/lduMatrix/solvers/GAMG/interfaces/GAMGInterface/GAMGInterface.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::GAMGInterface
  26
  27 Description
  28      Abstract base class for GAMG agglomerated interfaces.
  29
  30 SourceFiles
  31     GAMGInterface.C
  32     newAmgInterface.C
  33
  34 \*---------------------------------------------------------------------------*/
  35
  36 #ifndef GAMGInterface_H
  37 #define GAMGInterface_H
  38
  39 #include "autoPtr.H"
  40 #include "lduInterfacePtrsList.H"
  41
  42 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
  43
  44 namespace Foam
  45 {
  46
  47 /*---------------------------------------------------------------------------*\
  48                       Class GAMGInterface Declaration
  49 \*---------------------------------------------------------------------------*/
  50
  51 class GAMGInterface
  52 :
  53     public lduInterface
  54 {
  55
  56 protected:
  57
  58     // Protected data
  59
  60         //- My index in coarseInterfaces
  61         const label index_;
  62
  63         //- All interfaces
  64         const lduInterfacePtrsList& coarseInterfaces_;
  65
  66         //- Face-cell addressing
  67         labelField faceCells_;
  68
  69         //- Face restrict addressing
  70         labelField faceRestrictAddressing_;
  71
  72
  73 private:
  74
  75     // Private Member Functions
  76
  77         //- Disallow default bitwise copy construct
  78         GAMGInterface(const GAMGInterface&);
  79
  80         //- Disallow default bitwise assignment
  81         void operator=(const GAMGInterface&);
  82
  83
  84 public:
  85
  86     //- Runtime type information
  87     TypeName("GAMGInterface");
  88
  89
  90     // Declare run-time constructor selection tables
  91
  92         declareRunTimeSelectionTable
  93         (
  94             autoPtr,
  95             GAMGInterface,
  96             lduInterface,
  97             (
  98                 const label index,
  99                 const lduInterfacePtrsList& coarseInterfaces,
 100                 const lduInterface& fineInterface,
 101                 const labelField& localRestrictAddressing,
 102                 const labelField& neighbourRestrictAddressing
 103             ),
 104             (
 105                 index,
 106                 coarseInterfaces,
 107                 fineInterface,
 108                 localRestrictAddressing,
 109                 neighbourRestrictAddressing
 110             )
 111         );
 112
 113
 114     // Selectors
 115
 116         //- Return a pointer to a new interface created on freestore given
 117         //  the fine interface
 118         static autoPtr<GAMGInterface> New
 119         (
 120             const label index,
 121             const lduInterfacePtrsList& coarseInterfaces,
 122             const lduInterface& fineInterface,
 123             const labelField& localRestrictAddressing,
 124             const labelField& neighbourRestrictAddressing
 125         );
 126
 127
 128     // Constructors
 129
 130         //- Construct from fine-level interface,
 131         //  local and neighbour restrict addressing
 132         GAMGInterface
 133         (
 134             const label index,
 135             const lduInterfacePtrsList& coarseInterfaces,
 136             const lduInterface&,
 137             const labelField&,
 138             const labelField&
 139         )
 140         :
 141             index_(index),
 142             coarseInterfaces_(coarseInterfaces)
 143         {}
 144
 145
 146     // Member Functions
 147
 148         // Access
 149
 150             //- Return size
 151             virtual label size() const
 152             {
 153                 return faceCells_.size();
 154             }
 155
 156             virtual label index() const
 157             {
 158                 return index_;
 159             }
 160
 161             virtual const lduInterfacePtrsList& coarseInterfaces() const
 162             {
 163                 return coarseInterfaces_;
 164             }
 165
 166             //- Return faceCell addressing
 167             virtual const labelUList& faceCells() const
 168             {
 169                 return faceCells_;
 170             }
 171
 172             //- Return face restrict addressing
 173             virtual const labelList& faceRestrictAddressing() const
 174             {
 175                 return faceRestrictAddressing_;
 176             }
 177
 178             //- Return non-const access to face restrict addressing
 179             virtual labelList& faceRestrictAddressing()
 180             {
 181                 return faceRestrictAddressing_;
 182             }
 183
 184             //- Return the interface internal field of the given field
 185             template<class Type>
 186             tmp<Field<Type> > interfaceInternalField
 187             (
 188                 const UList<Type>& internalData
 189             ) const;
 190
 191             //- Return the values of the given internal data adjacent to
 192             //  the interface as a field
 193             virtual tmp<labelField> interfaceInternalField
 194             (
 195                 const labelUList& internalData
 196             ) const;
 197
 198
 199         // Agglomeration
 200
 201             //- Merge the next level with this level
 202             //  combining the face-restrict addressing
 203             //  and copying the face-cell addressing
 204             void combine(const GAMGInterface&);
 205
 206             //- Agglomerating the given fine-level coefficients and return
 207             virtual tmp<scalarField> agglomerateCoeffs
 208             (
 209                 const scalarField& fineCoeffs
 210             ) const;
 211 };
 212
 213
 214 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 215
 216 } // End namespace Foam
 217
 218 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 219
 220 #ifdef NoRepository
 221 #   include "GAMGInterfaceTemplates.C"
 222 #endif
 223
 224 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 225
 226 #endif
 227
 228 // ************************************************************************* //