src/blockMatrix/CoeffField/scalarCoeffField.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     Template specialisation for scalar coefficients
  30
  31 Author
  32     Hrvoje Jasak, Wikki Ltd.  All rights reserved.
  33
  34 SourceFiles
  35     tensorCoeffField.C
  36
  37 \*---------------------------------------------------------------------------*/
  38
  39 #ifndef scalarCoeffField_H
  40 #define scalarCoeffField_H
  41
  42 #include "CoeffField.H"
  43
  44 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
  45
  46 namespace Foam
  47 {
  48
  49 template<>
  50 class CoeffField<scalar>
  51 :
  52     public scalarField
  53 {
  54 public:
  55
  56     // Public data types
  57
  58         //- Component type
  59         typedef scalar scalarType;
  60         typedef scalar linearType;
  61
  62         //- Field type
  63         typedef scalarField scalarTypeField;
  64         typedef scalarField linearTypeField;
  65
  66
  67     // Static data members
  68
  69         static const char* const typeName;
  70
  71
  72     // Constructors
  73
  74         //- Construct given size
  75         explicit CoeffField<scalar>(const label size)
  76         :
  77             scalarField(size, pTraits<scalar>::zero)
  78         {}
  79
  80         //- Construct as copy
  81         CoeffField(const CoeffField<scalar>& f)
  82         :
  83             scalarField(f)
  84         {}
  85
  86         //- Construct from Istream
  87         CoeffField(Istream& is)
  88         :
  89             scalarField(is)
  90         {}
  91
  92
  93     // Member functions
  94
  95         //- Return active type
  96         blockCoeffBase::activeLevel activeType() const;
  97
  98         //- Return the field transpose
  99         tmp<CoeffField<scalar> > transpose() const;
 100
 101
 102         // Return as typed.  Fails when asked for the incorrect type
 103
 104             //- Return as scalar field
 105             const scalarField& asScalar() const;
 106             scalarField& asScalar();
 107
 108             //- Return as linear field.  Equal to scalar field
 109             const scalarField& asLinear() const;
 110             scalarField& asLinear();
 111
 112
 113         //- Return coefficient as a block
 114         BlockCoeff<scalar> getCoeff(const label index) const;
 115
 116         //- Set coefficient from a block
 117         void setCoeff(const label index, const BlockCoeff<scalar>& coeff);
 118
 119
 120         // Subset operations
 121
 122             //- Get subset with offset and size and store in given field
 123             void getSubset
 124             (
 125                 CoeffField<scalar>& f,
 126                 const label start,
 127                 const label size
 128             ) const;
 129
 130             //- Get subset with addressing and store in given field
 131             void getSubset
 132             (
 133                 CoeffField<scalar>& f,
 134                 const labelList& addr
 135             ) const;
 136
 137
 138             //- Set subset with offset and size from given field
 139             void setSubset
 140             (
 141                 const CoeffField<scalar>& f,
 142                 const label start,
 143                 const label size
 144             );
 145
 146             //- Get subset with addressing and store in target field
 147             void setSubset
 148             (
 149                 const CoeffField<scalar>& f,
 150                 const labelList& addr
 151             );
 152
 153             //- Zero out subset with offset and size
 154             void zeroOutSubset
 155             (
 156                 const label start,
 157                 const label size
 158             );
 159
 160             //- Zero out subset with addressing
 161             void zeroOutSubset
 162             (
 163                 const labelList& addr
 164             );
 165
 166             //- Add subset with addressing to field
 167             void addSubset
 168             (
 169                 const CoeffField<scalar>& f,
 170                 const labelList& addr
 171             );
 172
 173
 174     // Member operators
 175
 176         void operator=(const scalarField&);
 177         void operator=(const tmp<scalarField>&);
 178
 179
 180     // IOstream operators
 181
 182         friend Ostream& operator<<
 183         (
 184             Ostream&,
 185             const CoeffField<scalar>&
 186         );
 187
 188         friend Ostream& operator<<
 189         (
 190             Ostream&,
 191             const tmp<CoeffField<scalar> >&
 192         );
 193 };
 194
 195
 196 /* * * * * * * * * * * * * * * * Global operators  * * * * * * * * * * * * * */
 197
 198 template<>
 199 tmp<CoeffField<scalar> > inv(const CoeffField<scalar>& f);
 200
 201
 202 template<>
 203 void negate
 204 (
 205     CoeffField<scalar>& f,
 206     const CoeffField<scalar>& f1
 207 );
 208
 209
 210 template<>
 211 void multiply
 212 (
 213     scalarField& f,
 214     const CoeffField<scalar>& f1,
 215     const scalar& f2
 216 );
 217
 218
 219 template<>
 220 void multiply
 221 (
 222     scalarField& f,
 223     const CoeffField<scalar>& f1,
 224     const scalarField& f2
 225 );
 226
 227
 228 template<>
 229 void multiply
 230 (
 231     scalarField& f,
 232     const scalarField& f1,
 233     const CoeffField<scalar>& f2
 234 );
 235
 236
 237 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 238
 239 } // End namespace Foam
 240
 241 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 242
 243 #endif
 244
 245 // ************************************************************************* //