src/foam/matrices/blockLduMatrix/BlockLduMatrix/BlockConstraint/BlockConstraint.C

   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 Description
  25     A storage mechanism which allows setting of the fixed value and
  26     consequently recovering the equation for a single row of the matrix as
  27     well as the source. The equation is taken out of the matrix using a
  28     variant of compact matrix storage mechanism.
  29
  30 Author
  31     Hrvoje Jasak, Wikki Ltd.  All rights reserved.
  32
  33 \*---------------------------------------------------------------------------*/
  34
  35 #include "error.H"
  36
  37 #include "BlockConstraint.H"
  38 #include "demandDrivenData.H"
  39 #include "BlockLduMatrix.H"
  40
  41 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
  42
  43 namespace Foam
  44 {
  45
  46 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
  47
  48 // Construct from components
  49 template<class Type>
  50 BlockConstraint<Type>::BlockConstraint
  51 (
  52     const label row,
  53     const Type value,
  54     const Type& fixedCmpts
  55 )
  56 :
  57     rowID_(row),
  58     value_(value),
  59     fixedComponents_(fixedCmpts),
  60     matrixCoeffsSet_(false),
  61     diagCoeff_(),
  62     upperCoeffsOwnerPtr_(NULL),
  63     upperCoeffsNeighbourPtr_(NULL),
  64     lowerCoeffsOwnerPtr_(NULL),
  65     lowerCoeffsNeighbourPtr_(NULL)
  66 {}
  67
  68
  69 // Construct as copy
  70 template<class Type>
  71 BlockConstraint<Type>::BlockConstraint(const BlockConstraint& e)
  72 :
  73     rowID_(e.rowID_),
  74     value_(e.value_),
  75     fixedComponents_(e.fixedComponents_),
  76     matrixCoeffsSet_(false),
  77     upperCoeffsOwnerPtr_(NULL),
  78     upperCoeffsNeighbourPtr_(NULL),
  79     lowerCoeffsOwnerPtr_(NULL),
  80     lowerCoeffsNeighbourPtr_(NULL)
  81 {}
  82
  83
  84 // Construct from Istream
  85 template<class Type>
  86 BlockConstraint<Type>::BlockConstraint(Istream& is)
  87 :
  88     rowID_(readLabel(is)),
  89     value_(pTraits<Type>(is)),
  90     fixedComponents_(pTraits<Type>(is)),
  91     matrixCoeffsSet_(false),
  92     upperCoeffsOwnerPtr_(NULL),
  93     upperCoeffsNeighbourPtr_(NULL),
  94     lowerCoeffsOwnerPtr_(NULL),
  95     lowerCoeffsNeighbourPtr_(NULL)
  96 {}
  97
  98
  99 // * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
 100
 101 template<class Type>
 102 BlockConstraint<Type>::~BlockConstraint()
 103 {
 104     deleteDemandDrivenData(upperCoeffsOwnerPtr_);
 105     deleteDemandDrivenData(upperCoeffsNeighbourPtr_);
 106
 107     deleteDemandDrivenData(lowerCoeffsOwnerPtr_);
 108     deleteDemandDrivenData(lowerCoeffsNeighbourPtr_);
 109 }
 110
 111
 112 // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
 113
 114 template<class Type>
 115 const BlockCoeff<Type>& BlockConstraint<Type>::diagCoeff() const
 116 {
 117     if (matrixCoeffsSet_)
 118     {
 119         FatalErrorIn
 120         (
 121             "const BlockCoeff<Type>& BlockConstraint<Type>::diagCoeff() const"
 122         )   << "matrix coefficients not set"
 123             << abort(FatalError);
 124     }
 125
 126     return diagCoeff_;
 127 }
 128
 129
 130 template<class Type>
 131 const Type& BlockConstraint<Type>::b() const
 132 {
 133     if (matrixCoeffsSet_)
 134     {
 135         FatalErrorIn
 136         (
 137             "Type BlockConstraint<Type>::b() const"
 138         )   << "matrix coefficients not set"
 139             << abort(FatalError);
 140     }
 141
 142     return b_;
 143 }
 144
 145
 146 template<class Type>
 147 const CoeffField<Type>& BlockConstraint<Type>::upperCoeffsOwner() const
 148 {
 149     if (!upperCoeffsOwnerPtr_ || !matrixCoeffsSet_)
 150     {
 151         FatalErrorIn
 152         (
 153             "const CoeffField<Type>& BlockConstraint<Type>::"
 154             "upperCoeffsOwner() const"
 155         )   << "upper matrix coefficients not set"
 156             << abort(FatalError);
 157     }
 158
 159     return *upperCoeffsOwnerPtr_;
 160 }
 161
 162
 163 template<class Type>
 164 const CoeffField<Type>& BlockConstraint<Type>::upperCoeffsNeighbour() const
 165 {
 166     if (!upperCoeffsNeighbourPtr_ || !matrixCoeffsSet_)
 167     {
 168         FatalErrorIn
 169         (
 170             "const CoeffField<Type>& BlockConstraint<Type>::"
 171             "upperCoeffsNeighbour() const"
 172         )   << "upper matrix coefficients not set"
 173             << abort(FatalError);
 174     }
 175
 176     return *upperCoeffsNeighbourPtr_;
 177 }
 178
 179
 180 template<class Type>
 181 const CoeffField<Type>& BlockConstraint<Type>::lowerCoeffsOwner() const
 182 {
 183     if (!lowerCoeffsOwnerPtr_ || !matrixCoeffsSet_)
 184     {
 185         FatalErrorIn
 186         (
 187             "const CoeffField<Type>& BlockConstraint<Type>::"
 188             "lowerCoeffsOwner() const"
 189         )   << "lower matrix coefficients not set"
 190             << abort(FatalError);
 191     }
 192
 193     return *lowerCoeffsOwnerPtr_;
 194 }
 195
 196
 197 template<class Type>
 198 const CoeffField<Type>& BlockConstraint<Type>::lowerCoeffsNeighbour() const
 199 {
 200     if (!lowerCoeffsNeighbourPtr_ || !matrixCoeffsSet_)
 201     {
 202         FatalErrorIn
 203         (
 204             "const CoeffField<Type>& BlockConstraint<Type>::"
 205             "lowerCoeffsNeighbour() const"
 206         )   << "lower matrix coefficients not set"
 207             << abort(FatalError);
 208     }
 209
 210     return *lowerCoeffsNeighbourPtr_;
 211 }
 212
 213
 214 template<class Type>
 215 void BlockConstraint<Type>::combine
 216 (
 217     const BlockConstraint<Type>& e
 218 )
 219 {
 220     for
 221     (
 222         direction cmptI = 0;
 223         cmptI < pTraits<Type>::nComponents;
 224         cmptI++
 225     )
 226     {
 227         if
 228         (
 229             e.fixedComponents_.component(cmptI)
 230           > fixedComponents_.component(cmptI)
 231         )
 232         {
 233             fixedComponents_.component(cmptI) =
 234                 e.fixedComponents_.component(cmptI);
 235
 236             value_.replace(cmptI, e.value_.component(cmptI));
 237         }
 238     }
 239 }
 240
 241
 242 template<class Type>
 243 void BlockConstraint<Type>::clearMatrix()
 244 {
 245     matrixCoeffsSet_ = false;
 246
 247     diagCoeff_.clear();
 248
 249     b_ = pTraits<Type>::zero;
 250
 251     deleteDemandDrivenData(upperCoeffsOwnerPtr_);
 252     deleteDemandDrivenData(upperCoeffsNeighbourPtr_);
 253
 254     deleteDemandDrivenData(lowerCoeffsOwnerPtr_);
 255     deleteDemandDrivenData(lowerCoeffsNeighbourPtr_);
 256 }
 257
 258
 259 // * * * * * * * * * * * * * * * Member Operators  * * * * * * * * * * * * * //
 260
 261 template<class Type>
 262 void BlockConstraint<Type>::operator=
 263 (
 264     const BlockConstraint<Type>& rhs
 265 )
 266 {
 267     // Check for assignment to self
 268     if (this == &rhs)
 269     {
 270         FatalErrorIn
 271         (
 272             "BlockConstraint::operator=(const BlockConstraint&)"
 273         )   << "attempted assignment to self"
 274             << abort(FatalError);
 275     }
 276
 277     rowID_ = rhs.rowID_;
 278
 279     value_ = rhs.value_;
 280
 281     fixedComponents_ = rhs.fixedComponents_;
 282
 283     clearMatrix();
 284 }
 285
 286
 287 // * * * * * * * * * * * * * * * IOstream Operators  * * * * * * * * * * * * //
 288
 289 template<class Type>
 290 Ostream& operator<<(Ostream& os, const BlockConstraint<Type>& e)
 291 {
 292     os  << e.rowID_ << nl
 293         << e.value_ << nl
 294         << e.fixedComponents_ << nl;
 295
 296     os.check("Ostream& operator<<(Ostream&, BlockConstraint<Type>&");
 297
 298     return os;
 299 }
 300
 301
 302 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 303
 304 } // End namespace Foam
 305
 306 // ************************************************************************* //