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