src/thermophysicalModels/reactionThermo/chemistryReaders/chemkinReader/chemkinReader.H

   1 /*---------------------------------------------------------------------------*\
   2   =========                 |
   3   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
   4    \\    /   O peration     |
   5     \\  /    A nd           | Copyright (C) 1991-2009 OpenCFD Ltd.
   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., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
  24
  25 Class
  26     Foam::chemkinReader
  27
  28 Description
  29     Foam::chemkinReader
  30
  31 SourceFiles
  32     chemkinReader.C
  33     chemkinLexer.C
  34
  35 \*---------------------------------------------------------------------------*/
  36
  37 #ifndef chemkinReader_H
  38 #define chemkinReader_H
  39
  40 #include "chemistryReader.H"
  41 #include "fileName.H"
  42 #include "typeInfo.H"
  43 #include "HashPtrTable.H"
  44 #include "SLPtrList.H"
  45 #include "DynamicList.H"
  46 #include "labelList.H"
  47 #include "speciesTable.H"
  48 #include "atomicWeights.H"
  49
  50 #include "reactionTypes.H"
  51
  52 #include <FlexLexer.h>
  53
  54 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
  55
  56 namespace Foam
  57 {
  58
  59 /*---------------------------------------------------------------------------*\
  60                        Class chemkinReader Declaration
  61 \*---------------------------------------------------------------------------*/
  62
  63 class chemkinReader
  64 :
  65     public chemistryReader<gasThermoPhysics>,
  66     public yyFlexLexer
  67 {
  68
  69 public:
  70
  71     // Public data types
  72
  73         enum phase
  74         {
  75             solid,
  76             liquid,
  77             gas
  78         };
  79
  80         //- species element
  81         struct specieElement
  82         {
  83             word elementName;
  84             label nAtoms;
  85
  86             bool operator==(const specieElement& se) const
  87             {
  88                 return
  89                 (
  90                     nAtoms == se.nAtoms
  91                  && elementName == se.elementName
  92                 );
  93             }
  94
  95             bool operator!=(const specieElement& se) const
  96             {
  97                 return !operator==(se);
  98             }
  99
 100             friend Ostream& operator<<(Ostream& os, const specieElement& se)
 101             {
 102                 os  << se.nAtoms << token::SPACE << se.elementName;
 103                 return os;
 104             }
 105         };
 106
 107
 108 private:
 109
 110     // Private data
 111
 112         static int yyBufSize;
 113         label lineNo_;
 114
 115         //- Table of reaction type keywords
 116         HashTable<int> reactionKeywordTable_;
 117
 118         //- Currently supported reaction types
 119         enum reactionKeyword
 120         {
 121             thirdBodyReactionType,
 122             unimolecularFallOffReactionType,
 123             chemicallyActivatedBimolecularReactionType,
 124             TroeReactionType,
 125             SRIReactionType,
 126             LandauTellerReactionType,
 127             reverseLandauTellerReactionType,
 128             JanevReactionType,
 129             powerSeriesReactionRateType,
 130             radiationActivatedReactionType,
 131             speciesTempReactionType,
 132             energyLossReactionType,
 133             plasmaMomentumTransfer,
 134             collisionCrossSection,
 135             nonEquilibriumReversibleReactionType,
 136             duplicateReactionType,
 137             speciesOrderForward,
 138             speciesOrderReverse,
 139             UnitsOfReaction,
 140             end
 141         };
 142
 143         enum reactionType
 144         {
 145             irreversible,
 146             reversible,
 147             nonEquilibriumReversible,
 148             unknownReactionType
 149         };
 150
 151         static const char* reactionTypeNames[4];
 152
 153         enum reactionRateType
 154         {
 155             Arrhenius,
 156             thirdBodyArrhenius,
 157             unimolecularFallOff,
 158             chemicallyActivatedBimolecular,
 159             LandauTeller,
 160             Janev,
 161             powerSeries,
 162             unknownReactionRateType
 163         };
 164
 165         static const char* reactionRateTypeNames[8];
 166
 167         enum fallOffFunctionType
 168         {
 169             Lindemann,
 170             Troe,
 171             SRI,
 172             unknownFallOffFunctionType
 173         };
 174
 175         static const char* fallOffFunctionNames[4];
 176
 177
 178         void initReactionKeywordTable();
 179
 180
 181         //- List of elements
 182         DynamicList<word> elementNames_;
 183
 184         //- Element indices
 185         HashTable<label> elementIndices_;
 186
 187         //- Isotope molecular weights
 188         HashTable<scalar> isotopeAtomicWts_;
 189
 190         //- List of species
 191         DynamicList<word> specieNames_;
 192
 193         //- Specie indices
 194         HashTable<label> specieIndices_;
 195
 196         //- Table of species
 197         speciesTable speciesTable_;
 198
 199         //- Specie phase
 200         HashTable<phase> speciePhase_;
 201
 202         //- Table of the thermodynamic data given in the CHEMKIN file
 203         HashPtrTable<gasThermoPhysics> speciesThermo_;
 204
 205         //- Table of species composition
 206         HashTable<List<specieElement> > specieComposition_;
 207
 208         //- List of the reactions
 209         SLPtrList<gasReaction> reactions_;
 210
 211
 212     // Private Member Functions
 213
 214         //- Flex lexer to read the CHEMKIN III file
 215         int lex();
 216
 217         inline scalar stringToScalar(const string& s)
 218         {
 219             string& str = const_cast<string&>(s);
 220             str.replaceAll(" ", "");
 221             str.replaceAll("D", "e");
 222             str.replaceAll("d", "e");
 223             return atof(str.c_str());
 224         }
 225
 226         inline scalar stringToScalar(const char* cstr)
 227         {
 228             return stringToScalar(string(cstr));
 229         }
 230
 231         inline void correctElementName(word& elementName)
 232         {
 233             if (elementName.size() == 2)
 234             {
 235                 elementName[1] = tolower(elementName[1]);
 236             }
 237             else if(elementName[0] == 'E')
 238             {
 239                 elementName = 'e';
 240             }
 241         }
 242
 243         scalar molecularWeight
 244         (
 245             const List<specieElement>& specieComposition
 246         ) const;
 247
 248         void finishElements(labelList& currentAtoms);
 249
 250         void checkCoeffs
 251         (
 252             const scalarList& reactionCoeffs,
 253             const char* reationRateName,
 254             const label nCoeffs
 255         ) const;
 256
 257         template<class ReactionRateType>
 258         void addReactionType
 259         (
 260             const reactionType rType,
 261             DynamicList<gasReaction::specieCoeffs>& lhs,
 262             DynamicList<gasReaction::specieCoeffs>& rhs,
 263             const ReactionRateType& rr
 264         );
 265
 266         template<template<class, class> class PressureDependencyType>
 267         void addPressureDependentReaction
 268         (
 269             const reactionType rType,
 270             const fallOffFunctionType fofType,
 271             DynamicList<gasReaction::specieCoeffs>& lhs,
 272             DynamicList<gasReaction::specieCoeffs>& rhs,
 273             const scalarList& thirdBodyEfficiencies,
 274             const scalarList& k0Coeffs,
 275             const scalarList& kInfCoeffs,
 276             const HashTable<scalarList>& reactionCoeffsTable,
 277             const scalar Afactor0,
 278             const scalar AfactorInf,
 279             const scalar RR
 280         );
 281
 282         void addReaction
 283         (
 284             DynamicList<gasReaction::specieCoeffs>& lhs,
 285             DynamicList<gasReaction::specieCoeffs>& rhs,
 286             const scalarList& thirdBodyEfficiencies,
 287             const reactionType rType,
 288             const reactionRateType rrType,
 289             const fallOffFunctionType fofType,
 290             const scalarList& ArrheniusReactionCoeffs,
 291             HashTable<scalarList>& reactionCoeffsTable,
 292             const scalar RR
 293         );
 294
 295         // Read the CHEMKIN files
 296         void read
 297         (
 298             const fileName& CHEMKINFileName,
 299             const fileName& thermoFileName
 300         );
 301
 302
 303         //- Disallow default bitwise copy construct
 304         chemkinReader(const chemkinReader&);
 305
 306         //- Disallow default bitwise assignment
 307         void operator=(const chemkinReader&);
 308
 309
 310 public:
 311
 312     //- Runtime type information
 313     TypeName("chemkinReader");
 314
 315
 316     // Constructors
 317
 318         //- Construct from CHEMKIN III file name
 319         chemkinReader
 320         (
 321             const fileName& chemkinFile,
 322             const fileName& thermoFileName = fileName::null
 323         );
 324
 325         //- Construct by getting the CHEMKIN III file name from dictionary
 326         chemkinReader(const dictionary& thermoDict);
 327
 328
 329     // Destructor
 330
 331         virtual ~chemkinReader()
 332         {}
 333
 334
 335     // Member functions
 336
 337         //- List of elements
 338         const wordList& elementNames() const
 339         {
 340             return elementNames_;
 341         }
 342
 343         //- Element indices
 344         const HashTable<label>& elementIndices() const
 345         {
 346             return elementIndices_;
 347         }
 348
 349         //- Isotope molecular weights
 350         const HashTable<scalar>& isotopeAtomicWts() const
 351         {
 352             return isotopeAtomicWts_;
 353         }
 354
 355         //- Table of species
 356         const speciesTable& species() const
 357         {
 358             return speciesTable_;
 359         }
 360
 361         //- Specie phase
 362         const HashTable<phase>& speciePhase() const
 363         {
 364             return speciePhase_;
 365         }
 366
 367         //- Table of the thermodynamic data given in the CHEMKIN file
 368         const HashPtrTable<gasThermoPhysics>& speciesThermo() const
 369         {
 370             return speciesThermo_;
 371         }
 372
 373         //- Table of species composition
 374         const HashTable<List<specieElement> >& specieComposition() const
 375         {
 376             return specieComposition_;
 377         }
 378
 379         //- List of the reactions
 380         const SLPtrList<gasReaction>& reactions() const
 381         {
 382             return reactions_;
 383         }
 384 };
 385
 386
 387 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 388
 389 } // End namespace Foam
 390
 391 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 392
 393 #endif
 394
 395 // ************************************************************************* //