src/thermophysicalModels/chemistryModel/chemPoint/chemPoint.H

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