src/OpenFOAM/primitives/BlockCoeff/DecoupledBlockCoeff.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     BlockCoeff
  27
  28 Description
  29     Template for the terminal decoupled class.  It is designed to avoid
  30     endless expansion of tensor order by excluding block coupling at the
  31     terminal type level.
  32
  33 Author
  34     Hrvoje Jasak, Wikki Ltd.  All rights reserved
  35
  36 \*---------------------------------------------------------------------------*/
  37
  38 #ifndef DecoupledBlockCoeff_H
  39 #define DecoupledBlockCoeff_H
  40
  41 #include "blockCoeffBase.H"
  42 #include "Field.H"
  43
  44 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
  45
  46 namespace Foam
  47 {
  48
  49 // * * * * * * Forward declaration of template friend fuctions * * * * * * * //
  50
  51 template<class Type>
  52 class DecoupledBlockCoeff;
  53
  54 template<class Type>
  55 Ostream& operator<<(Ostream&, const DecoupledBlockCoeff<Type>&);
  56
  57 /*---------------------------------------------------------------------------*\
  58                       Class DecoupledBlockCoeff Declaration
  59 \*---------------------------------------------------------------------------*/
  60
  61 template<class Type>
  62 class DecoupledBlockCoeff
  63 :
  64     public blockCoeffBase
  65 {
  66 public:
  67
  68     // Public data types
  69
  70         //- Component type
  71         typedef Type xType;
  72         typedef Field<xType> xTypeField;
  73
  74         //- Coefficient type
  75         typedef scalar scalarType;
  76         typedef Type linearType;
  77
  78         //- Field type
  79         typedef Field<scalarType> scalarTypeField;
  80         typedef Field<linearType> linearTypeField;
  81
  82
  83     //- Multiplication trait
  84     class multiply
  85     {
  86     public:
  87
  88         multiply() {}
  89
  90         Type operator()(const scalarType& c, const Type& x) const
  91         {
  92             return c*x;
  93         }
  94
  95         Type operator()(const linearType& c, const Type& x) const
  96         {
  97             return cmptMultiply(c, x);
  98         }
  99
 100         Type operator()(const DecoupledBlockCoeff<Type>& c, const Type& x) const
 101         {
 102             if (c.scalarCoeffPtr_)
 103             {
 104                 return operator()(*c.scalarCoeffPtr_, x);
 105             }
 106             else if (c.linearCoeffPtr_)
 107             {
 108                 return operator()(*c.linearCoeffPtr_, x);
 109             }
 110             else
 111             {
 112                 return pTraits<Type>::zero;
 113             }
 114         }
 115
 116
 117         // Inverse functions
 118
 119             scalarType inverse(const scalarType& c) const
 120             {
 121                 return 1.0/c;
 122             }
 123
 124             linearType inverse(const linearType& c) const
 125             {
 126                 return cmptDivide(pTraits<linearType>::one, c);
 127             }
 128
 129
 130         // Triple product of coefficients
 131
 132             scalarType tripleProduct
 133             (
 134                 const scalarType& a,
 135                 const scalarType& b,
 136                 const scalarType& c
 137             ) const
 138             {
 139                 return a*c/b;
 140             }
 141
 142             linearType tripleProduct
 143             (
 144                 const linearType& a,
 145                 const linearType& b,
 146                 const linearType& c
 147             ) const
 148             {
 149                 return cmptDivide(cmptMultiply(a, c), b);
 150             }
 151
 152             linearType tripleProduct
 153             (
 154                 const scalarType& a,
 155                 const linearType& b,
 156                 const scalarType& c
 157             ) const
 158             {
 159                 return a*c*inverse(b);
 160             }
 161     };
 162
 163
 164 private:
 165
 166     // Private data
 167
 168         //- Scalar coefficient
 169         mutable scalarType* scalarCoeffPtr_;
 170
 171         //- Linear coefficient
 172         mutable linearType* linearCoeffPtr_;
 173
 174
 175     // Private Member Functions
 176
 177         //- Promote to scalar
 178         scalarType& toScalar();
 179
 180         //- Promote to linear
 181         linearType& toLinear();
 182
 183
 184 public:
 185
 186     // Constructors
 187
 188         //- Construct null
 189         explicit DecoupledBlockCoeff();
 190
 191         //- Construct as copy
 192         DecoupledBlockCoeff(const DecoupledBlockCoeff<Type>&);
 193
 194         //- Construct from Istream
 195         DecoupledBlockCoeff(Istream&);
 196
 197         //- Clone
 198         DecoupledBlockCoeff<Type> clone() const;
 199
 200
 201     // Destructor
 202
 203         ~DecoupledBlockCoeff();
 204
 205         //- Clear data
 206         void clear();
 207
 208
 209     // Member functions
 210
 211         //- Return active type
 212         blockCoeffBase::activeLevel activeType() const;
 213
 214         //- Check pointers: only one type should be active (debug only)
 215         void checkActive() const;
 216
 217         // Return as typed.  Fails when asked for the incorrect type
 218
 219             //- Return as scalar
 220             const scalarType& asScalar() const;
 221             scalarType& asScalar();
 222
 223             //- Return as linear
 224             const linearType& asLinear() const;
 225             linearType& asLinear();
 226
 227
 228         //- Return component
 229         scalarType component(const direction) const;
 230
 231
 232     // Member operators
 233
 234         void operator=(const DecoupledBlockCoeff<Type>&);
 235
 236
 237     // IOstream operators
 238
 239         friend Ostream& operator<< <Type>
 240         (
 241             Ostream&,
 242             const DecoupledBlockCoeff<Type>&
 243         );
 244 };
 245
 246
 247 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 248
 249 } // End namespace Foam
 250
 251 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 252
 253 #ifdef NoRepository
 254 #   include "DecoupledBlockCoeff.C"
 255 #endif
 256
 257 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 258
 259 #endif
 260
 261 // ************************************************************************* //