src/thermophysicalModels/chemistryModel/chemPoint/chemPoint.H

   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     Point of the binary tree.
  26
  27 \*---------------------------------------------------------------------------*/
  28
  29 #ifndef chemPoint_H
  30 #define chemPoint_H
  31
  32 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
  33
  34 #include "IOstream.H"
  35 #include "dictionary.H"
  36 #include "Switch.H"
  37 #include "scalarField.H"
  38
  39 namespace Foam
  40 {
  41
  42 class binaryNode;
  43
  44 /*---------------------------------------------------------------------------*\
  45                            Class chemPoint Declaration
  46 \*---------------------------------------------------------------------------*/
  47
  48 class chemPoint
  49 {
  50 public:
  51
  52         //- Reference to the node in the binary tree
  53         binaryNode* node_;
  54
  55
  56 private:
  57
  58
  59         //- Number of times the element has been used
  60         label nUsed_;
  61
  62         //- Vector storing the composition, temperature and pressure
  63         scalarField v0_;
  64
  65         //- Reaction mapping for v0
  66         scalarField r_;
  67
  68         //- Ellipsoid of accuracy
  69         scalarField EOA_;
  70
  71         //- Ellipsoid of accuracy for the solution
  72         scalarField solutionsEOA_;
  73
  74         //- tolerance for the Ellipsoid of accuracy
  75         scalar absErr_;
  76
  77         //- Use logarithm of temperature
  78         Switch logT_;
  79
  80         //- Time step, stored but not actually used
  81         scalar deltaT_;
  82
  83         //- Ellipsoid of accuracy for the time step
  84         scalar timeEOA_;
  85
  86
  87 public:
  88
  89     // Constructors
  90
  91         //- Construct from components
  92         chemPoint
  93         (
  94             const scalarField& v0,
  95             const scalarField& r,
  96             const scalarField& tolerances,
  97             const scalarField& tolerancesSolutions,
  98             const scalar& absErr,
  99             const Switch& logT,
 100             const scalar& deltaT
 101         );
 102
 103         //- Construct from components and reference to a binary node
 104         chemPoint
 105         (
 106             const scalarField& v0,
 107             const scalarField& r,
 108             const scalarField& tolerances,
 109             const scalarField& tolerancesSolutions,
 110             const scalar& absErr,
 111             const Switch& logT,
 112             const scalar& deltaT,
 113             binaryNode* node
 114         );
 115
 116         //- Construct from another chemPoint and reference to a binary node
 117         chemPoint
 118         (
 119             const chemPoint& p,
 120             binaryNode* node
 121         );
 122
 123         //- Construct from another chemPoint
 124         chemPoint
 125         (
 126             const chemPoint& p
 127         );
 128
 129
 130         //- Access
 131
 132         inline label& nUsed()
 133         {
 134             return nUsed_;
 135         }
 136
 137         inline const label& nUsed() const
 138         {
 139             return nUsed_;
 140         }
 141
 142         inline scalarField& v0()
 143         {
 144             return v0_;
 145         }
 146
 147         inline const scalarField& v0() const
 148         {
 149             return v0_;
 150         }
 151
 152         inline scalarField& r()
 153         {
 154             return r_;
 155         }
 156
 157         inline const scalarField& r() const
 158         {
 159             return r_;
 160         }
 161
 162         inline scalarField& EOA()
 163         {
 164             return EOA_;
 165         }
 166
 167         inline const scalarField& EOA() const
 168         {
 169             return EOA_;
 170         }
 171
 172         inline scalarField& solutionsEOA()
 173         {
 174             return solutionsEOA_;
 175         }
 176
 177         inline const scalarField& solutionsEOA() const
 178         {
 179             return solutionsEOA_;
 180         }
 181
 182         inline const scalar& absErr() const
 183         {
 184             return absErr_;
 185         }
 186
 187         inline Switch& logT()
 188         {
 189             return logT_;
 190         }
 191
 192         inline const Switch& logT() const
 193         {
 194             return logT_;
 195         }
 196
 197         inline binaryNode* node()
 198         {
 199             return node_;
 200         }
 201
 202         inline scalar& deltaT()
 203         {
 204             return deltaT_;
 205         }
 206
 207         inline const scalar& deltaT() const
 208         {
 209             return deltaT_;
 210         }
 211
 212         inline scalar& timeEOA()
 213         {
 214             return timeEOA_;
 215         }
 216
 217         inline const scalar& timeEOA() const
 218         {
 219             return timeEOA_;
 220         }
 221
 222
 223 //         scalar difference
 224 //         (
 225 //             const scalarField& point,
 226 //             const scalarField& scaleFactor,
 227 //             const bool& logT
 228 //         );
 229
 230         // Is the point in the ellipsoid of accuracy?
 231         bool inEOA
 232         (
 233             const scalarField& point,
 234             const scalarField& Wi,
 235             const scalar& rhoi,
 236             const scalar& deltaT,
 237             const scalarField& scaleFactor
 238         );
 239
 240         // Grow the ellipsoid of accuracy?
 241         void grow
 242         (
 243             const scalarField& v0,
 244             const scalarField& Wi,
 245             const scalar& rhoi,
 246             const scalarField& v,
 247             const scalar& deltaT
 248         );
 249
 250         // Check if the new solution is in the ellipsoid of accuracy?
 251         bool checkSolution
 252         (
 253             const scalarField& v0,
 254             const scalarField& v,
 255             const scalarField& Wi,
 256             const scalar& rhoi,
 257             const scalar& T,
 258             const scalar& p,
 259             const scalar& deltaT,
 260             const scalarField& tolerance
 261         );
 262
 263         //- Set free the point from its node, used for replacing
 264         //  in the binary tree
 265         void setFree();
 266
 267         // clear all the stored data
 268         void clearData();
 269 };
 270
 271
 272 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 273
 274 } // End namespace Foam
 275
 276 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 277
 278 #endif
 279
 280 // ************************************************************************* //