src/foam/matrices/blockLduMatrix/BlockLduMatrix/BlockConstraint/BlockConstraint.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     BlockConstraint
  26
  27 Description
  28     A storage mechanism which allows setting of the fixed value and
  29     consequently recovering the equation for a single row of the matrix as
  30     well as the b. The equation is taken out of the matrix using a
  31     variant of compact matrix storage mechanism.
  32
  33 Author
  34     Hrvoje Jasak, Wikki Ltd.  All rights reserved.
  35
  36 SourceFiles
  37     BlockConstraint.C
  38
  39 \*---------------------------------------------------------------------------*/
  40
  41 #ifndef BlockConstraint_H
  42 #define BlockConstraint_H
  43
  44 #include "BlockCoeff.H"
  45 #include "coeffFields.H"
  46 #include "blockLduMatrices.H"
  47
  48 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
  49
  50 namespace Foam
  51 {
  52
  53 template<class Type>
  54 class BlockConstraint;
  55
  56 template<class Type>
  57 Ostream& operator<<(Ostream&, const BlockConstraint<Type>&);
  58
  59
  60 /*---------------------------------------------------------------------------*\
  61                         Class BlockConstraint Declaration
  62 \*---------------------------------------------------------------------------*/
  63
  64 template<class Type>
  65 class BlockConstraint
  66 {
  67     // Public data types
  68
  69     typedef CoeffField<Type> TypeCoeffField;
  70     typedef Field<Type> TypeField;
  71
  72     // Private data
  73
  74         //- Matrix row ID
  75         label rowID_;
  76
  77         //- Fixed value
  78         Type value_;
  79
  80         //- Fixed components (0-1) 1 = fixed, 0 = free
  81         Type fixedComponents_;
  82
  83         //- Are matrix coefficients set?
  84         bool matrixCoeffsSet_;
  85
  86         //- Diagonal coefficient
  87         BlockCoeff<Type> diagCoeff_;
  88
  89         //- Right-hand side
  90         Type b_;
  91
  92         //- Upper coefficients, owner side
  93         TypeCoeffField* upperCoeffsOwnerPtr_;
  94
  95         //- Upper coefficients, neighbour side
  96         TypeCoeffField* upperCoeffsNeighbourPtr_;
  97
  98         //- Lower coefficients, owner side
  99         TypeCoeffField* lowerCoeffsOwnerPtr_;
 100
 101         //- Lower coefficients, neighbour side
 102         TypeCoeffField* lowerCoeffsNeighbourPtr_;
 103
 104
 105 public:
 106
 107
 108     // Constructors
 109
 110         //- Construct from components
 111         BlockConstraint
 112         (
 113             const label row,
 114             const Type value,
 115             const Type& fixedCmpts = pTraits<Type>::one
 116         );
 117
 118         //- Construct as copy
 119         BlockConstraint(const BlockConstraint&);
 120
 121         //- Construct from Istream
 122         BlockConstraint(Istream&);
 123
 124
 125     // Destructor
 126
 127         ~BlockConstraint();
 128
 129
 130     // Member Functions
 131
 132         //- Return matrix row ID
 133         label rowID() const
 134         {
 135             return rowID_;
 136         }
 137
 138         //- Return fixed value
 139         Type value() const
 140         {
 141             return value_;
 142         }
 143
 144         //- Return map of fixed components
 145         const Type& fixedComponents() const
 146         {
 147             return fixedComponents_;
 148         }
 149
 150         //- Return diagonal coefficient
 151         const BlockCoeff<Type>& diagCoeff() const;
 152
 153         //- Return right-hand side
 154         const Type& b() const;
 155
 156         //- Return off-diagonal coefficients
 157         const TypeCoeffField& upperCoeffsOwner() const;
 158
 159         const TypeCoeffField& upperCoeffsNeighbour() const;
 160
 161         const TypeCoeffField& lowerCoeffsOwner() const;
 162
 163         const TypeCoeffField& lowerCoeffsNeighbour() const;
 164
 165         //- Combine with existing equation
 166         void combine(const BlockConstraint<Type>&);
 167
 168         //- Set matrix coefficients
 169         void setMatrix
 170         (
 171             const BlockLduMatrix<Type>& matrix,
 172             const TypeField& x,
 173             const TypeField& b
 174         );
 175
 176
 177         //- Eliminate equation
 178         void eliminateEquation
 179         (
 180             BlockLduMatrix<Type>& matrix,
 181             TypeField& b
 182         ) const;
 183
 184         //- Set x, b and diagonal in eliminated equation
 185         void setSourceDiag
 186         (
 187             BlockLduMatrix<Type>&,
 188             Field<Type>& x,
 189             Field<Type>& b
 190         ) const;
 191
 192
 193         //- Reconstruct matrix coefficients
 194         void reconstructMatrix(BlockLduMatrix<Type>&) const;
 195
 196         //- Clear matrix coefficients
 197         void clearMatrix();
 198
 199
 200     // Member Operators
 201
 202         void operator=(const BlockConstraint<Type>&);
 203
 204
 205     // Ostream Operator
 206
 207         friend Ostream& operator<< <Type>
 208         (
 209             Ostream&,
 210             const BlockConstraint<Type>&
 211         );
 212 };
 213
 214
 215 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 216
 217 } // End namespace Foam
 218
 219 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 220
 221 #ifdef NoRepository
 222 #    include "BlockConstraint.C"
 223 #    include "BlockConstraintTools.C"
 224 #endif
 225
 226 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 227
 228 #endif
 229
 230 // ************************************************************************* //