src/blockMatrix/CoeffField/CoeffField.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     CoeffField<T>
  27
  28 Description
  29     Generic coefficient field type.  Used in BlockLduMatrix.  HJ, 2/Apr/2005
  30
  31 Author
  32     Hrvoje Jasak, Wikki Ltd.  All rights reserved
  33
  34 SourceFiles
  35     CoeffField.C
  36
  37 \*---------------------------------------------------------------------------*/
  38
  39 #ifndef CoeffField_H
  40 #define CoeffField_H
  41
  42 #include "VectorSpace.H"
  43 #include "primitiveFields.H"
  44 #include "blockCoeffs.H"
  45
  46 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
  47
  48 namespace Foam
  49 {
  50
  51 // * * * * * * Forward declaration of template friend fuctions * * * * * * * //
  52
  53 template<class Type>
  54 class CoeffField;
  55
  56 template<class Type>
  57 Ostream& operator<<(Ostream&, const CoeffField<Type>&);
  58
  59 template<class Type>
  60 Ostream& operator<<(Ostream&, const tmp<CoeffField<Type> >&);
  61
  62
  63 /*---------------------------------------------------------------------------*\
  64                           Class CoeffField Declaration
  65 \*---------------------------------------------------------------------------*/
  66
  67 template<class Type>
  68 class CoeffField
  69 :
  70     public refCount
  71 {
  72 public:
  73
  74     // Public data types
  75
  76         //- Component type
  77         typedef typename BlockCoeff<Type>::scalarType scalarType;
  78         typedef typename BlockCoeff<Type>::linearType linearType;
  79         typedef typename BlockCoeff<Type>::squareType squareType;
  80
  81         //- Field type
  82         typedef typename BlockCoeff<Type>::scalarTypeField scalarTypeField;
  83         typedef typename BlockCoeff<Type>::linearTypeField linearTypeField;
  84         typedef typename BlockCoeff<Type>::squareTypeField squareTypeField;
  85
  86
  87 private:
  88
  89     // Private data
  90
  91         //- Scalar coefficient
  92         mutable scalarTypeField* scalarCoeffPtr_;
  93
  94         //- Linear coefficient
  95         mutable linearTypeField* linearCoeffPtr_;
  96
  97         //- Square coefficient
  98         mutable squareTypeField* squareCoeffPtr_;
  99
 100         //- Number of elements
 101         label size_;
 102
 103
 104     // Private Member Functions
 105
 106         //- Check size for arithmetic operations: resizing is not allowed!
 107         template<class Type2>
 108         inline void checkSize(const UList<Type2>&) const;
 109
 110         //- Promote to scalar
 111         scalarTypeField& toScalar();
 112
 113         //- Promote to linear
 114         linearTypeField& toLinear();
 115
 116         //- Promote to square
 117         squareTypeField& toSquare();
 118
 119
 120 public:
 121
 122     // Static data members
 123
 124         static const char* const typeName;
 125
 126
 127     // Constructors
 128
 129         //- Construct given size
 130         explicit CoeffField(const label);
 131
 132         //- Construct as copy
 133         CoeffField(const CoeffField<Type>&);
 134
 135         //- Construct from Istream
 136         explicit CoeffField(Istream&);
 137
 138         //- Clone
 139         tmp<CoeffField<Type> > clone() const;
 140
 141
 142     // Destructor
 143
 144         ~CoeffField();
 145
 146         //- Clear data
 147         void clear();
 148
 149
 150     // Member functions
 151
 152         //- Return size
 153         inline label size() const;
 154
 155         //- Return active type
 156         blockCoeffBase::activeLevel activeType() const;
 157
 158         //- Check pointers: only one type should be active (debug only)
 159         void checkActive() const;
 160
 161         //- Negate this field
 162         void negate();
 163
 164         //- Return the field transpose
 165         tmp<CoeffField<Type> > transpose() const;
 166
 167
 168         // Return as typed.  Fails when asked for the incorrect type
 169
 170             //- Return as scalar field
 171             const scalarTypeField& asScalar() const;
 172
 173             //- Return as linear field
 174             const linearTypeField& asLinear() const;
 175
 176             //- Return as square field
 177             const squareTypeField& asSquare() const;
 178
 179
 180         // Return as typed.  Fails when asked for demotion
 181
 182             //- Return as scalar field
 183             scalarTypeField& asScalar();
 184
 185             //- Return as linear field
 186             linearTypeField& asLinear();
 187
 188             //- Return as square field
 189             squareTypeField& asSquare();
 190
 191
 192         //- Return component
 193         tmp<scalarTypeField> component(const direction) const;
 194
 195         //- Return coefficient as block
 196         BlockCoeff<Type> getCoeff(const label index) const;
 197
 198         //- Set coefficient from a block
 199         void setCoeff(const label index, const BlockCoeff<Type>& coeff);
 200
 201
 202         // Subset operations
 203
 204             //- Get subset with offset and size and store in given field
 205             void getSubset
 206             (
 207                 CoeffField<Type>& f,
 208                 const label start,
 209                 const label size
 210             ) const;
 211
 212             //- Get subset with addressing and store in given field
 213             void getSubset
 214             (
 215                 CoeffField<Type>& f,
 216                 const labelList& addr
 217             ) const;
 218
 219
 220             //- Set subset with offset and size from given field
 221             void setSubset
 222             (
 223                 const CoeffField<Type>& f,
 224                 const label start,
 225                 const label size
 226             );
 227
 228             //- Get subset with addressing and store in target field
 229             void setSubset
 230             (
 231                 const CoeffField<Type>& f,
 232                 const labelList& addr
 233             );
 234
 235             //- Zero out subset with offset and size
 236             void zeroOutSubset
 237             (
 238                 const label start,
 239                 const label size
 240             );
 241
 242             //- Zero out subset with addressing
 243             void zeroOutSubset
 244             (
 245                 const labelList& addr
 246             );
 247
 248             //- Add subset with addressing to field
 249             void addSubset
 250             (
 251                 const CoeffField<Type>& f,
 252                 const labelList& addr
 253             );
 254
 255
 256     // Member operators
 257
 258         void operator=(const CoeffField<Type>&);
 259         void operator=(const tmp<CoeffField<Type> >&);
 260
 261         void operator=(const scalarTypeField&);
 262         void operator=(const tmp<scalarTypeField>&);
 263         void operator=(const linearTypeField&);
 264         void operator=(const tmp<linearTypeField>&);
 265         void operator=(const squareTypeField&);
 266         void operator=(const tmp<squareTypeField>&);
 267
 268
 269         void operator+=(const CoeffField<Type>&);
 270         void operator+=(const tmp<CoeffField<Type> >&);
 271
 272         void operator+=(const scalarTypeField&);
 273         void operator+=(const tmp<scalarTypeField>&);
 274         void operator+=(const linearTypeField&);
 275         void operator+=(const tmp<linearTypeField>&);
 276         void operator+=(const squareTypeField&);
 277         void operator+=(const tmp<squareTypeField>&);
 278
 279         void operator-=(const CoeffField<Type>&);
 280         void operator-=(const tmp<CoeffField<Type> >&);
 281
 282         void operator-=(const scalarTypeField&);
 283         void operator-=(const tmp<scalarTypeField>&);
 284         void operator-=(const linearTypeField&);
 285         void operator-=(const tmp<linearTypeField>&);
 286         void operator-=(const squareTypeField&);
 287         void operator-=(const tmp<squareTypeField>&);
 288
 289         void operator*=(const UList<scalar>&);
 290         void operator*=(const tmp<Field<scalar> >&);
 291         void operator*=(const scalar&);
 292
 293         void operator/=(const UList<scalar>&);
 294         void operator/=(const tmp<Field<scalar> >&);
 295         void operator/=(const scalar&);
 296
 297
 298     // IOstream operators
 299
 300         friend Ostream& operator<< <Type>
 301         (
 302             Ostream&,
 303             const CoeffField<Type>&
 304         );
 305
 306         friend Ostream& operator<< <Type>
 307         (
 308             Ostream&,
 309             const tmp<CoeffField<Type> >&
 310         );
 311 };
 312
 313
 314 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 315
 316 } // End namespace Foam
 317
 318 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 319
 320 #include "CoeffFieldFunctions.H"
 321
 322 #ifdef NoRepository
 323 #   include "CoeffField.C"
 324 #endif
 325
 326 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 327
 328 #endif
 329
 330 // ************************************************************************* //