applications/utilities/thermophysical/IFCLookUpTableGen/IFCLookUpTableGen.C

   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 Application
  25     IFC (infinitely-fast chemistry) look-up table generator
  26
  27 Description
  28     Calculate the the infinitely-fast chemistry relationships in function of ft.
  29     for a given fuel.
  30     The output is given in moles.
  31
  32     i.e. dictionary:
  33
  34     fileName "SpeciesTable";
  35
  36
  37     fuel CH4(ANHARMONIC);
  38     n    1;
  39     m    4;
  40
  41
  42     fields
  43     (
  44         {
  45             name   ft;
  46             min    0.;
  47             max    1.;
  48             N      100;
  49         }
  50     );
  51
  52     output
  53     (
  54         {
  55             name    CH4;
  56         }
  57         {
  58             name    CO2;
  59         }
  60         {
  61             name    H2O;
  62         }
  63 );
  64
  65 \*---------------------------------------------------------------------------*/
  66
  67 #include "argList.H"
  68
  69 #include "IFstream.H"
  70 #include "OFstream.H"
  71
  72 #include "specieThermo.H"
  73 #include "janafThermo.H"
  74 #include "perfectGas.H"
  75
  76 #include "IOdictionary.H"
  77
  78 #include "interpolationLookUpTable.H"
  79
  80 using namespace Foam;
  81
  82 typedef specieThermo<janafThermo<perfectGas> > thermo;
  83
  84 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
  85
  86 int main(int argc, char *argv[])
  87 {
  88     argList::validArgs.clear();
  89     argList::validArgs.append("controlFile");
  90     argList args(argc, argv);
  91
  92     fileName controlFileName(args.additionalArgs()[0]);
  93
  94     enum varinput
  95     {
  96         fti,
  97         CH4i,
  98         CO2i,
  99         H2Oi
 100     };
 101
 102     // Construct control dictionary
 103     IFstream controlFile(controlFileName);
 104
 105     // Check controlFile stream is OK
 106     if (!controlFile.good())
 107     {
 108         FatalErrorIn(args.executable())
 109             << "Cannot read file " << controlFileName
 110             << exit(FatalError);
 111     }
 112
 113     dictionary control(controlFile);
 114
 115     //  fuel-air mix
 116     fileName BurcatCpDataFileName(findEtcFile("thermoData/BurcatCpData"));
 117
 118     // Construct control dictionary
 119     IFstream BurcatCpDataFile(BurcatCpDataFileName);
 120
 121     // Check BurcatCpData stream is OK
 122     if (!BurcatCpDataFile.good())
 123     {
 124         FatalErrorIn(args.executable())
 125         << "Cannot read file " << BurcatCpDataFileName
 126         << exit(FatalError);
 127     }
 128
 129     dictionary CpData(BurcatCpDataFile);
 130
 131     word fuelName(control.lookup("fuel"));
 132     scalar n(readScalar(control.lookup("n")));
 133     scalar m(readScalar(control.lookup("m")));
 134
 135     scalar stoicO2 = n + m/4.0;
 136     scalar stoicN2 = (0.79/0.21)*(n + m/4.0);
 137     scalar stoicCO2 = n;
 138     scalar stoicH2O = m/2.0;
 139
 140     thermo fuel
 141     (
 142         "fuel",
 143         thermo(CpData.lookup(fuelName))
 144     );
 145
 146     thermo oxidant
 147     (
 148         "oxidant",
 149         stoicO2*thermo(CpData.lookup("O2"))
 150       + stoicN2*thermo(CpData.lookup("N2"))
 151     );
 152
 153     dimensionedScalar stoicRatio
 154     (
 155         "stoichiometricAirFuelMassRatio",
 156         dimless,
 157         (oxidant.W()*oxidant.nMoles())/(fuel.W()*fuel.nMoles())
 158     );
 159
 160
 161     // Open File for Look Up Table
 162     fileName LookUpTableFile(control.lookup("fileName"));
 163
 164     OFstream controlFileOutput(LookUpTableFile);
 165
 166     if (!controlFileOutput.good())
 167     {
 168         FatalErrorIn(args.executable())
 169             << "Cannot open file " << LookUpTableFile
 170             << exit(FatalError);
 171     }
 172
 173     // Create Look Up Table
 174     interpolationLookUpTable<scalar> LookUpTable(control);
 175
 176     const List<label>& dim = LookUpTable.dim();
 177
 178     const List<scalar>& min = LookUpTable.min();
 179
 180     const List<scalar>& delta = LookUpTable.delta();
 181
 182     label count = 0;
 183
 184     for (label i=0; i <= dim[fti]; i++)
 185     {
 186         scalar ft = Foam::min(scalar(i)*delta[fti] + min[fti] + 0.001, 0.999);
 187
 188         scalar equiv = Foam::pow(((1.0 / ft) - 1.0), -1.0)*stoicRatio.value();
 189
 190         scalar o2 = (1.0/equiv)*stoicO2;
 191         scalar n2 = (0.79/0.21)*o2;
 192         scalar fres = max(1.0 - 1.0/equiv, 0.0);
 193         scalar ores = max(1.0/equiv - 1.0, 0.0);
 194         scalar fburnt = 1.0 - fres;
 195
 196
 197         thermo fuel
 198         (
 199             "fuel",
 200             fres*thermo(CpData.lookup(fuelName))
 201         );
 202
 203         thermo N2
 204         (
 205             "N2",
 206             n2*thermo(CpData.lookup("N2"))
 207         );
 208
 209         thermo O2
 210         (
 211             "O2",
 212             ores*thermo(CpData.lookup("O2"))
 213         );
 214
 215         thermo CO2
 216         (
 217             "CO2",
 218             fburnt*stoicCO2*thermo(CpData.lookup("CO2"))
 219         );
 220
 221         thermo H2O
 222         (
 223             "H2O",
 224             fburnt*stoicH2O*thermo(CpData.lookup("H2O"))
 225         );
 226
 227
 228         scalar ToTalMoles = fuel.nMoles() + CO2.nMoles() + H2O.nMoles() +
 229                 N2.nMoles() + O2.nMoles();
 230
 231         LookUpTable[fti][count] = ft;
 232         LookUpTable[CH4i][count] = fuel.nMoles()/ToTalMoles;
 233         LookUpTable[CO2i][count] = CO2.nMoles()/ToTalMoles;
 234         LookUpTable[H2Oi][count] = H2O.nMoles()/ToTalMoles;
 235         count++;
 236     }
 237
 238     IOobject::writeBanner(controlFileOutput);
 239     controlFileOutput << "\n" << nl;
 240     controlFileOutput.writeKeyword("fields");
 241     controlFileOutput << LookUpTable.entries() << token::END_STATEMENT << nl;
 242
 243     controlFileOutput.writeKeyword("output");
 244     controlFileOutput << LookUpTable.output() << token::END_STATEMENT << nl;
 245
 246     if (LookUpTable.size() == 0)
 247     {
 248         FatalErrorIn
 249         (
 250             "Foam::IFCLookUpTableGen"
 251         )   << "table is empty" << nl
 252             << exit(FatalError);
 253     }
 254
 255     controlFileOutput.writeKeyword("values");
 256     controlFileOutput << LookUpTable << token::END_STATEMENT << nl;
 257
 258     return(0);
 259 }
 260
 261
 262 // ************************************************************************* //