src/OpenFOAM/matrices/blockLduMatrix/BlockLduSolvers/BlockLduSolver/BlockLduSolver.H

   1 /*---------------------------------------------------------------------------*\
   2   =========                 |
   3   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
   4    \\    /   O peration     |
   5     \\  /    A nd           | Copyright (C) 2004-6 H. Jasak All rights reserved
   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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
  24
  25 Class
  26     BlockLduSolver
  27
  28 Description
  29     Linear equation solver for BlockLduMatrix.
  30
  31 Author
  32     Hrvoje Jasak, Wikki Ltd.  All rights reserved
  33
  34 SourceFiles
  35     BlockLduSolver.C
  36
  37 \*---------------------------------------------------------------------------*/
  38
  39 #ifndef BlockLduSolver_H
  40 #define BlockLduSolver_H
  41
  42 #include "blockLduMatrices.H"
  43 #include "runTimeSelectionTables.H"
  44
  45 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
  46
  47 namespace Foam
  48 {
  49
  50 // * * * * * * Forward declaration of template friend fuctions * * * * * * * //
  51
  52 template<class Type>
  53 class BlockSolverPerformance;
  54
  55 /*---------------------------------------------------------------------------*\
  56                         Class BlockLduSolver Declaration
  57 \*---------------------------------------------------------------------------*/
  58
  59 template<class Type>
  60 class BlockLduSolver
  61 {
  62     // Private data
  63
  64         //- Name of field being solved for
  65         word fieldName_;
  66
  67         //- Control data dictionary
  68         dictionary dict_;
  69
  70
  71 protected:
  72
  73     // Protected data types
  74
  75     typedef Field<Type> TypeField;
  76
  77
  78     // Protected data
  79
  80         //- Matrix
  81         const BlockLduMatrix<Type>& matrix_;
  82
  83
  84     // Protected Member Functions
  85
  86         //- Return dictionary
  87         const dictionary& dict() const
  88         {
  89             return dict_;
  90         }
  91
  92         //- Read a control parameter from the dictionary
  93         template<class T>
  94         void readControl
  95         (
  96             const dictionary& dict,
  97             T& control,
  98             const word& controlName
  99         );
 100
 101
 102 public:
 103
 104     //- Runtime type information
 105     TypeName("BlockLduSolver");
 106
 107
 108     // Static data
 109
 110         //- Large value for the use in solvers
 111         static const scalar great_;
 112
 113         //- Small value for the use in solvers
 114         static const scalar small_;
 115
 116
 117     // Declare run-time constructor selection tables
 118
 119         declareRunTimeSelectionTable
 120         (
 121             autoPtr,
 122             BlockLduSolver,
 123             symMatrix,
 124             (
 125                 const word& fieldName,
 126                 BlockLduMatrix<Type>& matrix,
 127                 const dictionary& dict
 128             ),
 129             (
 130                 fieldName,
 131                 matrix,
 132                 dict
 133             )
 134         );
 135
 136         declareRunTimeSelectionTable
 137         (
 138             autoPtr,
 139             BlockLduSolver,
 140             asymMatrix,
 141             (
 142                 const word& fieldName,
 143                 BlockLduMatrix<Type>& matrix,
 144                 const dictionary& dict
 145             ),
 146             (
 147                 fieldName,
 148                 matrix,
 149                 dict
 150             )
 151         );
 152
 153
 154
 155     // Constructors
 156
 157         //- Construct from field name and matrix
 158         BlockLduSolver
 159         (
 160             const word& fieldName,
 161             const BlockLduMatrix<Type>& matrix
 162         );
 163
 164         //- Construct from dictionary
 165         BlockLduSolver
 166         (
 167             const word& fieldName,
 168             const BlockLduMatrix<Type>& matrix,
 169             const dictionary& dict
 170         );
 171
 172
 173     // Selectors
 174
 175         //- Return a new solver
 176         static autoPtr<BlockLduSolver<Type> > New
 177         (
 178             const word& fieldName,
 179             BlockLduMatrix<Type>& matrix,
 180             const dictionary& dict
 181         );
 182
 183
 184     // Destructor
 185
 186         virtual ~BlockLduSolver()
 187         {}
 188
 189
 190     // Member functions
 191
 192         //- Return field name
 193         const word& fieldName() const
 194         {
 195             return fieldName_;
 196         }
 197
 198         //- Solve
 199         virtual BlockSolverPerformance<Type> solve
 200         (
 201             TypeField& x,
 202             const TypeField& b
 203         ) = 0;
 204 };
 205
 206
 207 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 208
 209 } // End namespace Foam
 210
 211 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 212
 213 #ifdef NoRepository
 214 #   include "BlockLduSolver.C"
 215 #endif
 216
 217
 218 #define makeBlockSolverTypeName(typeSolverType)                              \
 219                                                                              \
 220 defineNamedTemplateTypeNameAndDebug(typeSolverType, 0);
 221
 222 #define makeBlockSolvers(solverType)                                         \
 223                                                                              \
 224 makeBlockSolverTypeName(solverType##Scalar);                                 \
 225 makeBlockSolverTypeName(solverType##Vector);                                 \
 226 makeBlockSolverTypeName(solverType##Tensor);
 227
 228
 229 #define addSolverToBlockMatrix(Type, typeSolverType, typeMatrix)             \
 230                                                                              \
 231 addToRunTimeSelectionTable(block##Type##Solver, typeSolverType, typeMatrix);
 232
 233 #define addSolversToBlockMatrix(solverType, typeMatrix)                      \
 234                                                                              \
 235 addSolverToBlockMatrix(Scalar, solverType##Scalar, typeMatrix);              \
 236 addSolverToBlockMatrix(Vector, solverType##Vector, typeMatrix);              \
 237 addSolverToBlockMatrix(Tensor, solverType##Tensor, typeMatrix);
 238
 239 #define addSymSolverToBlockMatrix(solverType)                                \
 240                                                                              \
 241 addSolversToBlockMatrix(solverType, symMatrix);
 242
 243 #define addAsymSolverToBlockMatrix(solverType)                               \
 244                                                                              \
 245 addSolversToBlockMatrix(solverType, asymMatrix);
 246
 247
 248 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 249
 250 #endif
 251
 252 // ************************************************************************* //