From 72a226de177e90fe0ea51ed4db95b01c6e3c2891 Mon Sep 17 00:00:00 2001 From: changfly Date: Sat, 15 Sep 2018 20:55:34 +0900 Subject: [PATCH] SLFM gitlab version --- AMC/AMC.C | 49 ++++ AMC/AMC.H | 74 ++++++ AMC/AMCI.H | 54 +++++ BetaFunction/BetaFunction.C | 120 ++++++++++ BetaFunction/BetaFunction.H | 199 ++++++++++++++++ BetaFunction/BetaFunctionI.H | 58 +++++ BetaFunction/BetaFunctionIO.C | 65 ++++++ BetaGrid/BetaGrid.C | 126 ++++++++++ BetaGrid/BetaGrid.H | 161 +++++++++++++ BetaGrid/BetaGridI.H | 58 +++++ BetaGrid/BetaGridIO.C | 65 ++++++ BetaIntegrator/BetaIntegrator.C | 180 ++++++++++++++ BetaIntegrator/BetaIntegrator.H | 168 ++++++++++++++ BetaIntegrator/BetaIntegratorI.H | 58 +++++ BetaIntegrator/BetaIntegratorIO.C | 56 +++++ FlameStructure/FlameStructure.C | 206 ++++++++++++++++ FlameStructure/FlameStructure.H | 215 +++++++++++++++++ FlameStructure/FlameStructureI.H | 58 +++++ FlameStructure/FlameStructureIO.C | 72 ++++++ Make/files | 17 ++ Make/options | 34 +++ Mixturefraction.H | 10 + MixturefractionVar.H | 17 ++ SLFMFoam.C | 118 ++++++++++ UEqn.H | 20 ++ createFieldRefs.H | 2 + createFields.H | 374 ++++++++++++++++++++++++++++++ pEqn.H | 55 +++++ preIntegration.H | 78 +++++++ readSLFMlib.H | 33 +++ setEtaSpace.H | 51 ++++ setSDR.H | 79 +++++++ setVarSpace.H | 23 ++ updateT_RHO.H | 60 +++++ updateYi.H | 56 +++++ 35 files changed, 3069 insertions(+) create mode 100644 AMC/AMC.C create mode 100644 AMC/AMC.H create mode 100644 AMC/AMCI.H create mode 100644 BetaFunction/BetaFunction.C create mode 100644 BetaFunction/BetaFunction.H create mode 100644 BetaFunction/BetaFunctionI.H create mode 100644 BetaFunction/BetaFunctionIO.C create mode 100644 BetaGrid/BetaGrid.C create mode 100644 BetaGrid/BetaGrid.H create mode 100644 BetaGrid/BetaGridI.H create mode 100644 BetaGrid/BetaGridIO.C create mode 100644 BetaIntegrator/BetaIntegrator.C create mode 100644 BetaIntegrator/BetaIntegrator.H create mode 100644 BetaIntegrator/BetaIntegratorI.H create mode 100644 BetaIntegrator/BetaIntegratorIO.C create mode 100644 FlameStructure/FlameStructure.C create mode 100644 FlameStructure/FlameStructure.H create mode 100644 FlameStructure/FlameStructureI.H create mode 100644 FlameStructure/FlameStructureIO.C create mode 100644 Make/files create mode 100644 Make/options create mode 100644 Mixturefraction.H create mode 100644 MixturefractionVar.H create mode 100644 SLFMFoam.C create mode 100644 UEqn.H create mode 100644 createFieldRefs.H create mode 100644 createFields.H create mode 100644 pEqn.H create mode 100644 preIntegration.H create mode 100644 readSLFMlib.H create mode 100644 setEtaSpace.H create mode 100644 setSDR.H create mode 100644 setVarSpace.H create mode 100644 updateT_RHO.H create mode 100644 updateYi.H diff --git a/AMC/AMC.C b/AMC/AMC.C new file mode 100644 index 0000000..f76b956 --- /dev/null +++ b/AMC/AMC.C @@ -0,0 +1,49 @@ +/*---------------------------------------------------------------------------*\ + ========= | + \\ / F ield | OpenFOAM: The Open Source CFD Toolbox + \\ / O peration | + \\ / A nd | Copyright (C) 2016 OpenFOAM Foundation + \\/ M anipulation | +------------------------------------------------------------------------------- +License + This file is part of OpenFOAM. + + OpenFOAM is free software: you can redistribute it and/or modify it + under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + OpenFOAM is distributed in the hope that it will be useful, but WITHOUT + ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + for more details. + + You should have received a copy of the GNU General Public License + along with OpenFOAM. If not, see . + +\*---------------------------------------------------------------------------*/ + +#include "AMC.H" + +#include "error.H" + +// * * * * * * * * * * * * * Functions * * * * * * * * * * * * // + +//Amplitude Mapping Closure (from KIVA) +Foam::tmp Foam::CMC::AMC(const scalarField& eta) +{ + tmp tRes(new scalarField(eta.size(), 0.0)); + + scalarField& Res = tRes.ref(); + + for(label i=0 ; i. + +Function + Foam::CMC::AMC + +Description + +SourceFiles + AMC.C + +\*---------------------------------------------------------------------------*/ + +#ifndef AMC_H +#define AMC_H + +#include "tmp.H" +#include "scalarField.H" + +// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // + +namespace Foam +{ +namespace CMC +{ + +/*---------------------------------------------------------------------------*\ + Function AMC Declaration +\*---------------------------------------------------------------------------*/ + + const scalar pi = 3.141592; + + const scalar spi = Foam::sqrt(pi); + + //Amplitude Mapping Closure (from KIVA) + tmp AMC(const scalarField& eta); + + + //Amplitude Mapping Closure (from KIVA) + //Define exp(-2*(erf^-1(2*eta - 1))^2) + inline scalar AMC(const scalar eta); + +// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // + +} // End namespace CMC +} // End namespace Foam + +// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // + +#include "AMCI.H" + +#endif + +// ************************************************************************* // diff --git a/AMC/AMCI.H b/AMC/AMCI.H new file mode 100644 index 0000000..ad66372 --- /dev/null +++ b/AMC/AMCI.H @@ -0,0 +1,54 @@ +/*---------------------------------------------------------------------------*\ + ========= | + \\ / F ield | OpenFOAM: The Open Source CFD Toolbox + \\ / O peration | + \\ / A nd | Copyright (C) 2016 OpenFOAM Foundation + \\/ M anipulation | +------------------------------------------------------------------------------- +License + This file is part of OpenFOAM. + + OpenFOAM is free software: you can redistribute it and/or modify it + under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + OpenFOAM is distributed in the hope that it will be useful, but WITHOUT + ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + for more details. + + You should have received a copy of the GNU General Public License + along with OpenFOAM. If not, see . + +\*---------------------------------------------------------------------------*/ + +// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // + +// * * * * * * * * * * * * * Private Member Functions * * * * * * * * * * * // + + +//Amplitude Mapping Closure (from KIVA) +//Define exp(-2*(erf^-1(2*eta - 1))^2) +inline Foam::scalar Foam::CMC::AMC(const scalar eta) +{ + const scalar a0 = (2.0*eta - 1.0); + scalar a1 = 0.5; + scalar slope; + scalar da = GREAT; + + while(mag(da) > SMALL) + { + slope = (2.0/spi)*Foam::exp(-1.0*Foam::pow(a1,2.0)); + da = (a0 - Foam::erf(a1))/slope; + a1 = a1 + da; + } + + return Foam::exp(-2.0*Foam::pow(a1,2.0)); +} + + +// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // + + +// ************************************************************************* // diff --git a/BetaFunction/BetaFunction.C b/BetaFunction/BetaFunction.C new file mode 100644 index 0000000..b6a13ae --- /dev/null +++ b/BetaFunction/BetaFunction.C @@ -0,0 +1,120 @@ +/*---------------------------------------------------------------------------*\ + ========= | + \\ / F ield | OpenFOAM: The Open Source CFD Toolbox + \\ / O peration | + \\ / A nd | Copyright (C) 2016 OpenFOAM Foundation + \\/ M anipulation | +------------------------------------------------------------------------------- +License + This file is part of OpenFOAM. + + OpenFOAM is free software: you can redistribute it and/or modify it + under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + OpenFOAM is distributed in the hope that it will be useful, but WITHOUT + ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + for more details. + + You should have received a copy of the GNU General Public License + along with OpenFOAM. If not, see . + +\*---------------------------------------------------------------------------*/ + +#include "BetaFunction.H" + +#include "error.H" + +// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * // + +// const scalar Foam::CMC::BetaFunction::staticData(); + + +// * * * * * * * * * * * * * Static Member Functions * * * * * * * * * * * * // + + +// * * * * * * * * * * * * * Private Member Functions * * * * * * * * * * * // + +void Foam::CMC::BetaFunction::_setParameters() +{ + scalar gamma = mf_*(1.0 - mf_)/(mfVar_ + SMALL) - 1.0; + + if (gamma < SMALL || (mfVar_)/(mf_*(1 - mf_) + SMALL) < 0.001) + { + fdelta_ = true; + } + else + { + a_ = max(mf_*gamma, 0.0); + b_ = max((1.0 - mf_)*gamma, 0.0); + + if(a_ < 1.0) + { + delta0_ = true; + } + if(b_ < 1.0) + { + delta1_ = true; + } + + _limitAB(); + } +} + + +void Foam::CMC::BetaFunction::_limitAB() +{ + scalar fmax = 1.0/(1.0 + (b_ - 1.0)/(a_ - 1.0)); + + if(a_ > 500.0) + { + a_ = 500.0; + b_ = (a_ - 1.0 - fmax*(a_ - 2.0))/fmax; + } + else if(b_ > 500.0) + { + b_ = 500.0; + a_ = (1.0 + fmax*(b_ - 2.0))/(1.0 - fmax); + } +} + +// * * * * * * * * * * * * Protected Member Functions * * * * * * * * * * * // + + +// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * // + +Foam::CMC::BetaFunction::BetaFunction(const scalar mf, const scalar mfVar) +: + mf_(mf), + mfVar_(mfVar), + a_(0.0), + b_(0.0), + fdelta_(false), + delta0_(false), + delta1_(false) +{ + _setParameters(); +} + + +// * * * * * * * * * * * * * * * * Destructor * * * * * * * * * * * * * * * // + +Foam::CMC::BetaFunction::~BetaFunction() +{} + + +// * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * * // + + +// * * * * * * * * * * * * * * Member Operators * * * * * * * * * * * * * * // + + +// * * * * * * * * * * * * * * Friend Functions * * * * * * * * * * * * * * // + + +// * * * * * * * * * * * * * * Friend Operators * * * * * * * * * * * * * * // + + +// ************************************************************************* // diff --git a/BetaFunction/BetaFunction.H b/BetaFunction/BetaFunction.H new file mode 100644 index 0000000..81c2d04 --- /dev/null +++ b/BetaFunction/BetaFunction.H @@ -0,0 +1,199 @@ +/*---------------------------------------------------------------------------*\ + ========= | + \\ / F ield | OpenFOAM: The Open Source CFD Toolbox + \\ / O peration | + \\ / A nd | Copyright (C) 2016 OpenFOAM Foundation + \\/ M anipulation | +------------------------------------------------------------------------------- +License + This file is part of OpenFOAM. + + OpenFOAM is free software: you can redistribute it and/or modify it + under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + OpenFOAM is distributed in the hope that it will be useful, but WITHOUT + ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + for more details. + + You should have received a copy of the GNU General Public License + along with OpenFOAM. If not, see . + +Class + Foam::BetaFunction + +Description + +SourceFiles + BetaFunctionI.H + BetaFunction.C + BetaFunctionIO.C + +\*---------------------------------------------------------------------------*/ + +#ifndef BetaFunction_H +#define BetaFunction_H + +#include "scalar.H" +#include "Switch.H" +#include "scalarField.H" +#include "tmp.H" + +// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // + +namespace Foam +{ + +// Forward declaration of classes +class Istream; +class Ostream; + +// Forward declaration of friend functions and operators +namespace CMC +{ + class BetaFunction; +} +Istream& operator>>(Istream&, CMC::BetaFunction&); +Ostream& operator<<(Ostream&, const CMC::BetaFunction&); + + +/*---------------------------------------------------------------------------*\ + Class BetaFunction Declaration +\*---------------------------------------------------------------------------*/ + +namespace CMC +{ + +class BetaFunction +{ + // Private data + + //- Mean mixture fraction + scalar mf_; + + //- Mixture fraction variance + scalar mfVar_; + + //- Beta pdf parameter alpha + scalar a_; + + //- Beta pdf parameter beta + scalar b_; + + //- Flag beta pdf special case: forced-delta function + Switch fdelta_; + + //- delta function at pure oxidizer stream + Switch delta0_; + + //- delta function at pure fuel stream + Switch delta1_; + + + // Private Member Functions + + //- Calculate alpha and beta and set special case flags + void _setParameters(); + + //- Limit too large value of beta pdf parameters + void _limitAB(); + + //- Disallow default bitwise copy construct + // BetaFunction(const BetaFunction&); + + //- Disallow default bitwise assignment + // void operator=(const BetaFunction&); + + +public: + + // Static data members + + //- Static data staticData + // static const scalar staticData; + + + // Constructors + + //- Construct from components + BetaFunction(const scalar mf, const scalar mfVar); + + //- Construct from Istream + BetaFunction(Istream&); + + //- Construct as copy + // BetaFunction(const BetaFunction&); + + + //- Destructor + ~BetaFunction(); + + + // Member Functions + + tmp etaFunc(const UList& eta) const + { + return pow(eta, a_-1.0)*pow(1.0-eta, b_-1.0); + } + + scalar etaFunc(const scalar eta) const + { + return Foam::pow(eta, a_-1.0)*Foam::pow(1.0-eta, b_-1.0); + } + + + // Access + + Switch fdelta() const {return fdelta_;} + + Switch delta0() const {return delta0_;} + + Switch delta1() const {return delta1_;} + + scalar mf() const {return mf_;} + + scalar mfVar() const {return mfVar_;} + + scalar alpha() const {return a_;} + + scalar beta() const {return b_;} + + // Check + + // Edit + + // Write + + + // Member Operators + + // void operator=(const BetaFunction&); + + + // Friend Functions + + // Friend Operators + + // IOstream Operators + + friend Istream& ::Foam::operator>>(Istream&, BetaFunction&); + friend Ostream& ::Foam::operator<<(Ostream&, const BetaFunction&); +}; + + +// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // + +} // End namespace CMC +} // End namespace Foam + +// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // + +#include "BetaFunctionI.H" + +// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // + +#endif + +// ************************************************************************* // diff --git a/BetaFunction/BetaFunctionI.H b/BetaFunction/BetaFunctionI.H new file mode 100644 index 0000000..eca8d9e --- /dev/null +++ b/BetaFunction/BetaFunctionI.H @@ -0,0 +1,58 @@ +/*---------------------------------------------------------------------------*\ + ========= | + \\ / F ield | OpenFOAM: The Open Source CFD Toolbox + \\ / O peration | + \\ / A nd | Copyright (C) 2016 OpenFOAM Foundation + \\/ M anipulation | +------------------------------------------------------------------------------- +License + This file is part of OpenFOAM. + + OpenFOAM is free software: you can redistribute it and/or modify it + under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + OpenFOAM is distributed in the hope that it will be useful, but WITHOUT + ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + for more details. + + You should have received a copy of the GNU General Public License + along with OpenFOAM. If not, see . + +\*---------------------------------------------------------------------------*/ + +// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // + +// * * * * * * * * * * * * * Private Member Functions * * * * * * * * * * * // + + +// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * // + + +// * * * * * * * * * * * * * * * * Destructor * * * * * * * * * * * * * * * // + + +// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * // + + +// * * * * * * * * * * * * * * * Member Operators * * * * * * * * * * * * * // + + +// * * * * * * * * * * * * * * * Friend Functions * * * * * * * * * * * * * // + + +// * * * * * * * * * * * * * * * Friend Operators * * * * * * * * * * * * * // + + +// * * * * * * * * * * * * * * IOstream Operators * * * * * * * * * * * * * // + + +// * * * * * * * * * * * * * * * Ostream Operator * * * * * * * * * * * * * // + + +// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // + + +// ************************************************************************* // diff --git a/BetaFunction/BetaFunctionIO.C b/BetaFunction/BetaFunctionIO.C new file mode 100644 index 0000000..9d568fa --- /dev/null +++ b/BetaFunction/BetaFunctionIO.C @@ -0,0 +1,65 @@ +/*---------------------------------------------------------------------------*\ + ========= | + \\ / F ield | OpenFOAM: The Open Source CFD Toolbox + \\ / O peration | + \\ / A nd | Copyright (C) 2016 OpenFOAM Foundation + \\/ M anipulation | +------------------------------------------------------------------------------- +License + This file is part of OpenFOAM. + + OpenFOAM is free software: you can redistribute it and/or modify it + under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + OpenFOAM is distributed in the hope that it will be useful, but WITHOUT + ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + for more details. + + You should have received a copy of the GNU General Public License + along with OpenFOAM. If not, see . + +\*---------------------------------------------------------------------------*/ + +#include "BetaFunction.H" +#include "IOstreams.H" + +// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * // + +Foam::CMC::BetaFunction::BetaFunction(Istream& is) +{ + // Check state of Istream + is.check("Foam::CMC::BetaFunction::BetaFunction(Foam::Istream&)"); +} + + +// * * * * * * * * * * * * * * * IOstream Operators * * * * * * * * * * * * // + +Foam::Istream& Foam::operator>>(Istream& is, CMC::BetaFunction&) +{ + // Check state of Istream + is.check + ( + "Foam::Istream& Foam::operator>>(Foam::Istream&, Foam::CMC::BetaFunction&)" + ); + + return is; +} + + +Foam::Ostream& Foam::operator<<(Ostream& os, const CMC::BetaFunction&) +{ + // Check state of Ostream + os.check + ( + "Foam::Ostream& Foam::operator<<(Foam::Ostream&, " + "const Foam::CMC::BetaFunction&)" + ); + + return os; +} + + +// ************************************************************************* // diff --git a/BetaGrid/BetaGrid.C b/BetaGrid/BetaGrid.C new file mode 100644 index 0000000..71b4211 --- /dev/null +++ b/BetaGrid/BetaGrid.C @@ -0,0 +1,126 @@ +/*---------------------------------------------------------------------------*\ + ========= | + \\ / F ield | OpenFOAM: The Open Source CFD Toolbox + \\ / O peration | + \\ / A nd | Copyright (C) 2016 OpenFOAM Foundation + \\/ M anipulation | +------------------------------------------------------------------------------- +License + This file is part of OpenFOAM. + + OpenFOAM is free software: you can redistribute it and/or modify it + under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + OpenFOAM is distributed in the hope that it will be useful, but WITHOUT + ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + for more details. + + You should have received a copy of the GNU General Public License + along with OpenFOAM. If not, see . + +\*---------------------------------------------------------------------------*/ + +#include "BetaGrid.H" + +#include "error.H" +#include "dictionary.H" +#include "SubList.H" + +// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * // + +// const scalar Foam::CMC::BetaGrid::staticData(); + + +// * * * * * * * * * * * * * Static Member Functions * * * * * * * * * * * * // + + +// * * * * * * * * * * * * * Private Member Functions * * * * * * * * * * * // + + +// * * * * * * * * * * * * Protected Member Functions * * * * * * * * * * * // + + +// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * // + +Foam::CMC::BetaGrid::BetaGrid(const dictionary& dict) +: + etaCut_(dict.lookup("detailedEta")), + nSpacings_(dict.lookup("detailedN")), + etaSpace_(sum(nSpacings_)+3) +{ + // Check for input list size + if (etaCut_.size() != nSpacings_.size() + 1) + { + FatalErrorInFunction + << "Number of grid interval points does not match number of grid sizes" + << abort(FatalError); + } + + // Check for evenness of number of spacings in each interval + forAll (nSpacings_, i) + { + if ((nSpacings_[i] % 2) == 1) + { + FatalErrorInFunction + << "Number of spacings in intervals should be even" + << abort(FatalError); + } + } + + forAll(nSpacings_, i) + { + const label ns = nSpacings_[i]; + const labelList::subList prev(nSpacings_, i); + const label baseI = sum(prev) + 1; + + const scalar low = etaCut_[i]; + const scalar upp = etaCut_[i+1]; + const scalar delta = (upp - low) / scalar(ns); + + for (label j = 0; j < ns; j++) + { + etaSpace_[baseI+j] = low + delta * j; + } + } + etaSpace_[0] = 0.0; + etaSpace_[etaSpace_.size()-2] = etaCut_.last(); + etaSpace_[etaSpace_.size()-1] = 1.0; +} + + +Foam::CMC::BetaGrid::BetaGrid(const BetaGrid&) +{} + + +// * * * * * * * * * * * * * * * * Destructor * * * * * * * * * * * * * * * // + +Foam::CMC::BetaGrid::~BetaGrid() +{} + + +// * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * * // + + +// * * * * * * * * * * * * * * Member Operators * * * * * * * * * * * * * * // + +void Foam::CMC::BetaGrid::operator=(const BetaGrid& rhs) +{ + // Check for assignment to self + if (this == &rhs) + { + FatalErrorInFunction + << "Attempted assignment to self" + << abort(FatalError); + } +} + +// * * * * * * * * * * * * * * Friend Functions * * * * * * * * * * * * * * // + + +// * * * * * * * * * * * * * * Friend Operators * * * * * * * * * * * * * * // + + +// ************************************************************************* // diff --git a/BetaGrid/BetaGrid.H b/BetaGrid/BetaGrid.H new file mode 100644 index 0000000..fc17e0a --- /dev/null +++ b/BetaGrid/BetaGrid.H @@ -0,0 +1,161 @@ +/*---------------------------------------------------------------------------*\ + ========= | + \\ / F ield | OpenFOAM: The Open Source CFD Toolbox + \\ / O peration | + \\ / A nd | Copyright (C) 2016 OpenFOAM Foundation + \\/ M anipulation | +------------------------------------------------------------------------------- +License + This file is part of OpenFOAM. + + OpenFOAM is free software: you can redistribute it and/or modify it + under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + OpenFOAM is distributed in the hope that it will be useful, but WITHOUT + ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + for more details. + + You should have received a copy of the GNU General Public License + along with OpenFOAM. If not, see . + +Class + Foam::BetaGrid + +Description + +SourceFiles + BetaGridI.H + BetaGrid.C + BetaGridIO.C + +\*---------------------------------------------------------------------------*/ + +#ifndef BetaGrid_H +#define BetaGrid_H + +#include "scalarField.H" +#include "labelList.H" + +// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // + +namespace Foam +{ + +// Forward declaration of classes +class Istream; +class Ostream; + +// Forward declaration of friend functions and operators +namespace CMC +{ + class BetaGrid; +} +class dictionary; + +Istream& operator>>(Istream&, CMC::BetaGrid&); +Ostream& operator<<(Ostream&, const CMC::BetaGrid&); + + +/*---------------------------------------------------------------------------*\ + Class BetaGrid Declaration +\*---------------------------------------------------------------------------*/ + +namespace CMC +{ + +class BetaGrid +{ + // Private data + + //- Piecewise uniform interval points + scalarField etaCut_; + + //- Sizes of piecewise uniform intervals + labelList nSpacings_; + + //- Mixture fraction eta grid points + scalarField etaSpace_; + + + // Private Member Functions + + //- Disallow default bitwise copy construct + BetaGrid(const BetaGrid&); + + //- Disallow default bitwise assignment + void operator=(const BetaGrid&); + + +public: + + // Static data members + + //- Static data staticData + // static const scalar staticData; + + + // Constructors + + //- Construct from components + BetaGrid(const dictionary& dict); + + //- Construct from Istream + BetaGrid(Istream&); + + //- Construct as copy + // BetaGrid(const BetaGrid&); + + + //- Destructor + ~BetaGrid(); + + + // Member Functions + + // Access + const labelList& N() const {return nSpacings_;} + + const scalarField& etaCut() const {return etaCut_;} + + const scalarField& etaSpace() const {return etaSpace_;} + + // Check + + // Edit + + // Write + + + // Member Operators + + // void operator=(const BetaGrid&); + + + // Friend Functions + + // Friend Operators + + // IOstream Operators + + friend Istream& ::Foam::operator>>(Istream&, BetaGrid&); + friend Ostream& ::Foam::operator<<(Ostream&, const BetaGrid&); +}; + + +// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // + +} // End namespace CMC +} // End namespace Foam + +// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // + +#include "BetaGridI.H" + +// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // + +#endif + +// ************************************************************************* // diff --git a/BetaGrid/BetaGridI.H b/BetaGrid/BetaGridI.H new file mode 100644 index 0000000..eca8d9e --- /dev/null +++ b/BetaGrid/BetaGridI.H @@ -0,0 +1,58 @@ +/*---------------------------------------------------------------------------*\ + ========= | + \\ / F ield | OpenFOAM: The Open Source CFD Toolbox + \\ / O peration | + \\ / A nd | Copyright (C) 2016 OpenFOAM Foundation + \\/ M anipulation | +------------------------------------------------------------------------------- +License + This file is part of OpenFOAM. + + OpenFOAM is free software: you can redistribute it and/or modify it + under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + OpenFOAM is distributed in the hope that it will be useful, but WITHOUT + ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + for more details. + + You should have received a copy of the GNU General Public License + along with OpenFOAM. If not, see . + +\*---------------------------------------------------------------------------*/ + +// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // + +// * * * * * * * * * * * * * Private Member Functions * * * * * * * * * * * // + + +// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * // + + +// * * * * * * * * * * * * * * * * Destructor * * * * * * * * * * * * * * * // + + +// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * // + + +// * * * * * * * * * * * * * * * Member Operators * * * * * * * * * * * * * // + + +// * * * * * * * * * * * * * * * Friend Functions * * * * * * * * * * * * * // + + +// * * * * * * * * * * * * * * * Friend Operators * * * * * * * * * * * * * // + + +// * * * * * * * * * * * * * * IOstream Operators * * * * * * * * * * * * * // + + +// * * * * * * * * * * * * * * * Ostream Operator * * * * * * * * * * * * * // + + +// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // + + +// ************************************************************************* // diff --git a/BetaGrid/BetaGridIO.C b/BetaGrid/BetaGridIO.C new file mode 100644 index 0000000..d567d45 --- /dev/null +++ b/BetaGrid/BetaGridIO.C @@ -0,0 +1,65 @@ +/*---------------------------------------------------------------------------*\ + ========= | + \\ / F ield | OpenFOAM: The Open Source CFD Toolbox + \\ / O peration | + \\ / A nd | Copyright (C) 2016 OpenFOAM Foundation + \\/ M anipulation | +------------------------------------------------------------------------------- +License + This file is part of OpenFOAM. + + OpenFOAM is free software: you can redistribute it and/or modify it + under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + OpenFOAM is distributed in the hope that it will be useful, but WITHOUT + ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + for more details. + + You should have received a copy of the GNU General Public License + along with OpenFOAM. If not, see . + +\*---------------------------------------------------------------------------*/ + +#include "BetaGrid.H" +#include "IOstreams.H" + +// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * // + +Foam::CMC::BetaGrid::BetaGrid(Istream& is) +{ + // Check state of Istream + is.check("Foam::CMC::BetaGrid::BetaGrid(Foam::Istream&)"); +} + + +// * * * * * * * * * * * * * * * IOstream Operators * * * * * * * * * * * * // + +Foam::Istream& Foam::operator>>(Istream& is, CMC::BetaGrid&) +{ + // Check state of Istream + is.check + ( + "Foam::Istream& Foam::operator>>(Foam::Istream&, Foam::CMC::BetaGrid&)" + ); + + return is; +} + + +Foam::Ostream& Foam::operator<<(Ostream& os, const CMC::BetaGrid&) +{ + // Check state of Ostream + os.check + ( + "Foam::Ostream& Foam::operator<<(Foam::Ostream&, " + "const Foam::CMC::BetaGrid&)" + ); + + return os; +} + + +// ************************************************************************* // diff --git a/BetaIntegrator/BetaIntegrator.C b/BetaIntegrator/BetaIntegrator.C new file mode 100644 index 0000000..fc16c5f --- /dev/null +++ b/BetaIntegrator/BetaIntegrator.C @@ -0,0 +1,180 @@ +/*---------------------------------------------------------------------------*\ + ========= | + \\ / F ield | OpenFOAM: The Open Source CFD Toolbox + \\ / O peration | + \\ / A nd | Copyright (C) 2016 OpenFOAM Foundation + \\/ M anipulation | +------------------------------------------------------------------------------- +License + This file is part of OpenFOAM. + + OpenFOAM is free software: you can redistribute it and/or modify it + under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + OpenFOAM is distributed in the hope that it will be useful, but WITHOUT + ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + for more details. + + You should have received a copy of the GNU General Public License + along with OpenFOAM. If not, see . + +\*---------------------------------------------------------------------------*/ + +#include "BetaIntegrator.H" + + +#include "error.H" +#include "SubList.H" +#include "SubField.H" +#include "interpolateXY.H" + +// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * // + +// const scalar Foam::CMC::BetaIntegrator::staticData(); + + +// * * * * * * * * * * * * * Static Member Functions * * * * * * * * * * * * // + + +// * * * * * * * * * * * * * Private Member Functions * * * * * * * * * * * // + +//extended Simpson's rule (Numerical recipes, 2nd Ed. p.128) +//for equally spaced and even N intervals (or odd N+1 points) +Foam::scalar Foam::CMC::BetaIntegrator::simps +(const scalar xl, const scalar xh, const label n, const UList& fx) + const +{ + scalar evensum(0.0), oddsum(0.0), sum(0.0); + + scalar h = (xh - xl)/scalar(n); + + for(label i=0 ; i& f) const +{ + scalar total = 0.0; + + const labelList &N(bg_.N()); + const scalarField &etaCut(bg_.etaCut()); + + forAll(N, i) + { + const labelList::subList prev(N, i); + const label baseI = sum(prev) + 1; + + const scalarField::subField subInterval(f, N[i]+1, baseI); + + total += simps(etaCut[i], etaCut[i+1], N[i], subInterval); + } + + return total; +} + +// * * * * * * * * * * * * Protected Member Functions * * * * * * * * * * * // + + +// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * // + +Foam::CMC::BetaIntegrator::BetaIntegrator(const BetaFunction& bf, const BetaGrid &bg) +: + etaSpace_(bg.etaSpace()), + pdfNum_(bg.etaSpace().size(), 0.0), + pdfDen_(0.0), + bf_(bf), + bg_(bg) +{ + const scalarField::subField domain(etaSpace_, etaSpace_.size()-2, 1); + scalarField::subField range(pdfNum_, etaSpace_.size()-2, 1); + + if (bf_.fdelta()) + { + pdfDen_ = 1.0; + } + else + { + range = bf_.etaFunc(domain); + + if (!bf_.delta0()) + { + pdfNum_.first() = bf_.etaFunc(etaSpace_.first()); + } + + if (!bf_.delta1()) + { + pdfNum_.last() = bf_.etaFunc(etaSpace_.last()); + } + + pdfDen_ = sumSimps(pdfNum_) + + Foam::pow(etaSpace_[1], bf_.alpha())/(bf_.alpha() + SMALL) + + Foam::pow(etaSpace_[1], bf_.beta())/(bf_.beta() + SMALL); + } +} + + +// * * * * * * * * * * * * * * * * Destructor * * * * * * * * * * * * * * * // + +Foam::CMC::BetaIntegrator::~BetaIntegrator() +{} + + +// * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * * // + +// beta-pdf weighted integration for given mf, mfVar and f +Foam::scalar Foam::CMC::BetaIntegrator::betaIntegrate(const scalarField& f) const +{ + scalar result = 0.0; + + if(bf_.fdelta()) + { + result = interpolateXY(bf_.mf(), etaSpace_, f); + } + else + { + scalar num = sumSimps (f * pdfNum_) + + f.first()*Foam::pow(etaSpace_[1], bf_.alpha())/(bf_.alpha() + SMALL) + + f.last()*Foam::pow(etaSpace_[1], bf_.beta())/(bf_.beta() + SMALL); + result = num/pdfDen_; + } + + return result; +} + +// * * * * * * * * * * * * * * Member Operators * * * * * * * * * * * * * * // + +void Foam::CMC::BetaIntegrator::operator=(const BetaIntegrator& rhs) +{ + // Check for assignment to self + if (this == &rhs) + { + FatalErrorInFunction + << "Attempted assignment to self" + << abort(FatalError); + } +} + +// * * * * * * * * * * * * * * Friend Functions * * * * * * * * * * * * * * // + + +// * * * * * * * * * * * * * * Friend Operators * * * * * * * * * * * * * * // + + +// ************************************************************************* // diff --git a/BetaIntegrator/BetaIntegrator.H b/BetaIntegrator/BetaIntegrator.H new file mode 100644 index 0000000..692bff5 --- /dev/null +++ b/BetaIntegrator/BetaIntegrator.H @@ -0,0 +1,168 @@ +/*---------------------------------------------------------------------------*\ + ========= | + \\ / F ield | OpenFOAM: The Open Source CFD Toolbox + \\ / O peration | + \\ / A nd | Copyright (C) 2016 OpenFOAM Foundation + \\/ M anipulation | +------------------------------------------------------------------------------- +License + This file is part of OpenFOAM. + + OpenFOAM is free software: you can redistribute it and/or modify it + under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + OpenFOAM is distributed in the hope that it will be useful, but WITHOUT + ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + for more details. + + You should have received a copy of the GNU General Public License + along with OpenFOAM. If not, see . + +Class + Foam::CMC::BetaIntegrator + +Description + +SourceFiles + BetaIntegratorI.H + BetaIntegrator.C + BetaIntegratorIO.C + +\*---------------------------------------------------------------------------*/ + +#ifndef BetaIntegrator_H +#define BetaIntegrator_H + +#include "scalarField.H" +#include "BetaFunction.H" +#include "BetaGrid.H" + +// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // + +namespace Foam +{ + +// Forward declaration of classes +class Istream; +class Ostream; + +// Forward declaration of friend functions and operators +namespace CMC +{ + class BetaIntegrator; +} +Istream& operator>>(Istream&, CMC::BetaIntegrator&); +Ostream& operator<<(Ostream&, const CMC::BetaIntegrator&); + + +/*---------------------------------------------------------------------------*\ + Class BetaIntegrator Declaration +\*---------------------------------------------------------------------------*/ + +namespace CMC +{ + +class BetaIntegrator +{ + // Private data + + //- Quadrature points + const scalarField &etaSpace_; + + //- Beta pdf numerators + scalarField pdfNum_; + + //- Beta pdf denominator + scalar pdfDen_; + + //- Description of data_ + BetaFunction bf_; + + //- Description of data_ + const BetaGrid &bg_; + + + // Private Member Functions + + //- Calculate integral using Simpson's rule + scalar simps(const scalar xl, const scalar xh, const label n, const UList& fx) const; + + //- Calculate integral using Simpson's rule + scalar sumSimps(const UList& f) const; + + //- Disallow default bitwise copy construct + BetaIntegrator(const BetaIntegrator&); + + //- Disallow default bitwise assignment + void operator=(const BetaIntegrator&); + + +public: + + // Static data members + + //- Static data staticData + // static const scalar staticData; + + + // Constructors + + //- Construct from components + BetaIntegrator(const BetaFunction& bf, const BetaGrid &bg); + + //- Construct as copy + // BetaIntegrator(const BetaIntegrator&); + + + //- Destructor + ~BetaIntegrator(); + + + // Member Functions + + scalar betaIntegrate(const scalarField& f) const; + + // Access + + scalar pdfDen () const {return pdfDen_;} + + // Check + + // Edit + + // Write + + + // Member Operators + + // void operator=(const BetaIntegrator&); + + + // Friend Functions + + // Friend Operators + + // IOstream Operators + + friend Istream& ::Foam::operator>>(Istream&, BetaIntegrator&); + friend Ostream& ::Foam::operator<<(Ostream&, const BetaIntegrator&); +}; + + +// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // + +} // End namespace CMC +} // End namespace Foam + +// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // + +#include "BetaIntegratorI.H" + +// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // + +#endif + +// ************************************************************************* // diff --git a/BetaIntegrator/BetaIntegratorI.H b/BetaIntegrator/BetaIntegratorI.H new file mode 100644 index 0000000..eca8d9e --- /dev/null +++ b/BetaIntegrator/BetaIntegratorI.H @@ -0,0 +1,58 @@ +/*---------------------------------------------------------------------------*\ + ========= | + \\ / F ield | OpenFOAM: The Open Source CFD Toolbox + \\ / O peration | + \\ / A nd | Copyright (C) 2016 OpenFOAM Foundation + \\/ M anipulation | +------------------------------------------------------------------------------- +License + This file is part of OpenFOAM. + + OpenFOAM is free software: you can redistribute it and/or modify it + under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + OpenFOAM is distributed in the hope that it will be useful, but WITHOUT + ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + for more details. + + You should have received a copy of the GNU General Public License + along with OpenFOAM. If not, see . + +\*---------------------------------------------------------------------------*/ + +// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // + +// * * * * * * * * * * * * * Private Member Functions * * * * * * * * * * * // + + +// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * // + + +// * * * * * * * * * * * * * * * * Destructor * * * * * * * * * * * * * * * // + + +// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * // + + +// * * * * * * * * * * * * * * * Member Operators * * * * * * * * * * * * * // + + +// * * * * * * * * * * * * * * * Friend Functions * * * * * * * * * * * * * // + + +// * * * * * * * * * * * * * * * Friend Operators * * * * * * * * * * * * * // + + +// * * * * * * * * * * * * * * IOstream Operators * * * * * * * * * * * * * // + + +// * * * * * * * * * * * * * * * Ostream Operator * * * * * * * * * * * * * // + + +// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // + + +// ************************************************************************* // diff --git a/BetaIntegrator/BetaIntegratorIO.C b/BetaIntegrator/BetaIntegratorIO.C new file mode 100644 index 0000000..8818197 --- /dev/null +++ b/BetaIntegrator/BetaIntegratorIO.C @@ -0,0 +1,56 @@ +/*---------------------------------------------------------------------------*\ + ========= | + \\ / F ield | OpenFOAM: The Open Source CFD Toolbox + \\ / O peration | + \\ / A nd | Copyright (C) 2016 OpenFOAM Foundation + \\/ M anipulation | +------------------------------------------------------------------------------- +License + This file is part of OpenFOAM. + + OpenFOAM is free software: you can redistribute it and/or modify it + under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + OpenFOAM is distributed in the hope that it will be useful, but WITHOUT + ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + for more details. + + You should have received a copy of the GNU General Public License + along with OpenFOAM. If not, see . + +\*---------------------------------------------------------------------------*/ + +#include "BetaIntegrator.H" +#include "IOstreams.H" + +// * * * * * * * * * * * * * * * IOstream Operators * * * * * * * * * * * * // + +Foam::Istream& Foam::operator>>(Istream& is, CMC::BetaIntegrator&) +{ + // Check state of Istream + is.check + ( + "Foam::Istream& Foam::operator>>(Foam::Istream&, Foam::CMC::BetaIntegrator&)" + ); + + return is; +} + + +Foam::Ostream& Foam::operator<<(Ostream& os, const CMC::BetaIntegrator&) +{ + // Check state of Ostream + os.check + ( + "Foam::Ostream& Foam::operator<<(Foam::Ostream&, " + "const Foam::CMC::BetaIntegrator&)" + ); + + return os; +} + + +// ************************************************************************* // diff --git a/FlameStructure/FlameStructure.C b/FlameStructure/FlameStructure.C new file mode 100644 index 0000000..3d37bca --- /dev/null +++ b/FlameStructure/FlameStructure.C @@ -0,0 +1,206 @@ +/*---------------------------------------------------------------------------*\ + ========= | + \\ / F ield | OpenFOAM: The Open Source CFD Toolbox + \\ / O peration | + \\ / A nd | Copyright (C) 2016 OpenFOAM Foundation + \\/ M anipulation | +------------------------------------------------------------------------------- +License + This file is part of OpenFOAM. + + OpenFOAM is free software: you can redistribute it and/or modify it + under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + OpenFOAM is distributed in the hope that it will be useful, but WITHOUT + ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + for more details. + + You should have received a copy of the GNU General Public License + along with OpenFOAM. If not, see . + +\*---------------------------------------------------------------------------*/ + +#include "FlameStructure.H" + +#include "fileName.H" +#include "IFstream.H" +#include "hashedWordList.H" +#include "interpolateXY.H" + +// * * * * * * * * * * * * * Private Member Functions * * * * * * * * * * * // + + +// * * * * * * * * * * * * Protected Member Functions * * * * * * * * * * * // + + +// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * // + +Foam::SLFM::FlameStructure::FlameStructure(const string& NstDir, scalarList NstList, const scalarField &etaGrid, const hashedWordList &spTable) +: + NstDir_(NstDir), + NstList_(NstList), + eta_(etaGrid), + species_(spTable), + Y_(spTable.size(), scalarFieldArray1d(NstList_.size(), scalarField(eta_.size(), 0.0))), + W_(spTable.size(), scalarFieldArray1d(NstList_.size(), scalarField(eta_.size(), 0.0))), + T_(NstList_.size(), scalarField(eta_.size(), 0.0)), + Q_(NstList_.size(), scalarField(eta_.size(), 0.0)), + h_(NstList_.size(), scalarField(eta_.size(), 0.0)), + rho_(NstList_.size(), scalarField(eta_.size(), 0.0)), + Rgas_(NstList_.size(), scalarField(eta_.size(), 0.0)) +{ + for (label n = 0; n < NstList_.size(); n++) + { + scalar N = NstList_[n]; + + fileName fname = "sdr"+Foam::name(N)+".inp"; + IFstream fin(NstDir_/fname); + + string gbg; + label etamax_SLFM, NoSpecies; + + //INPUT FILE... + fin.getLine(gbg); + + //No.GRID... + fin.getLine(gbg); + + //Number of eta-point and species + fin >> etamax_SLFM >> NoSpecies; + + //blank line + fin.getLine(gbg); + + //PRESSURE... + fin.getLine(gbg); + + //1.00... + fin.getLine(gbg); + + //MIXTURE... + fin.getLine(gbg); + + //read eta space (from SLFM library) + scalarField etaValue_SLFM(etamax_SLFM, 0.0); + for(label j = 0 ; j < etamax_SLFM ; j++) + { + fin>>etaValue_SLFM[j]; + } + + //blank line + fin.getLine(gbg); + + //INITIAL... + fin.getLine(gbg); + + //species loop + scalarField temp(etamax_SLFM, 0.0); + for(label i = 0 ; i < NoSpecies ; i++) + { + word spName; + //H2... (species name) + fin >> spName; + const label spI (species_[spName]); + + // Info << spI << spName << endl; + + //read species mass fraction (from SLFM library) + for(label j=0 ; j> Yj; + temp[j] = max(0.0, Yj); + } + + Y_[spI][n] = interpolateXY(etaGrid, etaValue_SLFM, temp); + + //read reaction rate (from SLFM library) + for(label j = 0 ; j < etamax_SLFM ; j++) + { + fin>>temp[j]; + } + + W_[spI][n] = interpolateXY(etaGrid, etaValue_SLFM, temp); + + //blank line + fin.getLine(gbg); + } + + //read temperature + { + //H2... (species name) + fin.getLine(gbg); + + //read temperature + for(label j = 0 ; j < etamax_SLFM ; j++) + { + scalar Yj = 0.0; + fin >> Yj; + temp[j] = max(0.0, Yj); + } + + T_[n] = interpolateXY(etaGrid, etaValue_SLFM, temp); + + //read heat source + for(label j = 0 ; j < etamax_SLFM ; j++) + { + fin>>temp[j]; + } + + Q_[n] = interpolateXY(etaGrid, etaValue_SLFM, temp); + + //blank line + fin.getLine(gbg); + } + + //DENSITY... + fin.getLine(gbg); + + //read density (from SLFM library) + for(label j = 0 ; j < etamax_SLFM ; j++) + { + fin>>temp[j]; + } + //Info<>temp[j]; + } + + h_[n] = interpolateXY(etaGrid, etaValue_SLFM, temp); + } +} + + +// * * * * * * * * * * * * * * * * Destructor * * * * * * * * * * * * * * * // + +Foam::SLFM::FlameStructure::~FlameStructure() +{} + + +// * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * * // + + +// * * * * * * * * * * * * * * Member Operators * * * * * * * * * * * * * * // + + +// * * * * * * * * * * * * * * Friend Functions * * * * * * * * * * * * * * // + + +// * * * * * * * * * * * * * * Friend Operators * * * * * * * * * * * * * * // + + +// ************************************************************************* // diff --git a/FlameStructure/FlameStructure.H b/FlameStructure/FlameStructure.H new file mode 100644 index 0000000..96a5ba8 --- /dev/null +++ b/FlameStructure/FlameStructure.H @@ -0,0 +1,215 @@ +/*---------------------------------------------------------------------------*\ + ========= | + \\ / F ield | OpenFOAM: The Open Source CFD Toolbox + \\ / O peration | + \\ / A nd | Copyright (C) 2016 OpenFOAM Foundation + \\/ M anipulation | +------------------------------------------------------------------------------- +License + This file is part of OpenFOAM. + + OpenFOAM is free software: you can redistribute it and/or modify it + under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + OpenFOAM is distributed in the hope that it will be useful, but WITHOUT + ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + for more details. + + You should have received a copy of the GNU General Public License + along with OpenFOAM. If not, see . + +Class + Foam::SLFM::FlameStructure + +Description + +SourceFiles + FlameStructureI.H + FlameStructure.C + FlameStructureIO.C + +\*---------------------------------------------------------------------------*/ + +#ifndef FlameStructure_H +#define FlameStructure_H + +#include "error.H" +#include "scalarField.H" + +// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // + +namespace Foam +{ + +// Forward declaration of classes +class Istream; +class Ostream; + +class hashedWordList; + +namespace SLFM +{ + class FlameStructure; +} + +// Forward declaration of friend functions and operators +Istream& operator>>(Istream&, SLFM::FlameStructure&); +Ostream& operator<<(Ostream&, const SLFM::FlameStructure&); + +namespace SLFM +{ + +/*---------------------------------------------------------------------------*\ + Class FlameStructure Declaration +\*---------------------------------------------------------------------------*/ + +class FlameStructure +{ + // Private data + typedef List scalarFieldArray1d; + + typedef List scalarFieldArray2d; + + typedef List scalarFieldArray3d; + + //- Species mass fraction + word NstDir_; + + //- Species mass fraction + const scalarList NstList_; + + //- Species mass fraction + const scalarField eta_; + + //- Species mass fraction + const hashedWordList &species_; + + //- Species mass fraction + scalarFieldArray2d Y_; + + //- Species production rate + scalarFieldArray2d W_; + + //- Temperature + scalarFieldArray1d T_; + + //- Heat source + scalarFieldArray1d Q_; + + //- Enthalpy + scalarFieldArray1d h_; + + //- Density + scalarFieldArray1d rho_; + + //- Specific gas constant for mean W + scalarFieldArray1d Rgas_; + + + // Private Member Functions + + //- Disallow Construct null + FlameStructure(); + + //- Disallow default bitwise copy construct + // FlameStructure(const FlameStructure&); + + //- Disallow default bitwise assignment + // void operator=(const FlameStructure&); + + +public: + + // Static data members + + //- Static data staticData + // static const dataType staticData; + + + // Constructors + + //- Construct from components + FlameStructure(const string& NstDir, scalarList NstList, const scalarField &etaGrid, const hashedWordList& spTable); + + //- Construct from Istream + // FlameStructure(Istream&); + + //- Construct as copy + // FlameStructure(const FlameStructure&); + + + // Selectors + + //- Select null constructed + // static autoPtr New(); + + + //- Destructor + ~FlameStructure(); + + + // Member Functions + + // Access + + //- Select null constructed + scalarFieldArray2d& Y() {return Y_;} + + //- Select null constructed + scalarFieldArray2d& W() {return W_;} + + //- Select null constructed + scalarFieldArray1d& T() {return T_;} + + //- Select null constructed + scalarFieldArray1d& Q() {return Q_;} + + //- Select null constructed + scalarFieldArray1d& rho() {return rho_;} + + //- Select null constructed + scalarFieldArray1d& h() {return h_;} + + //- Select null constructed + scalarFieldArray1d& Rgas() {return Rgas_;} + + // Check + + // Edit + + // Write + + + // Member Operators + + // void operator=(const FlameStructure&); + + + // Friend Functions + + // Friend Operators + + // IOstream Operators + + friend Istream& operator>>(Istream&, FlameStructure&); + friend Ostream& operator<<(Ostream&, const FlameStructure&); +}; + + +// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // + +} // End namespace SLFM +} // End namespace Foam + +// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // + +#include "FlameStructureI.H" + +// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // + +#endif + +// ************************************************************************* // diff --git a/FlameStructure/FlameStructureI.H b/FlameStructure/FlameStructureI.H new file mode 100644 index 0000000..eca8d9e --- /dev/null +++ b/FlameStructure/FlameStructureI.H @@ -0,0 +1,58 @@ +/*---------------------------------------------------------------------------*\ + ========= | + \\ / F ield | OpenFOAM: The Open Source CFD Toolbox + \\ / O peration | + \\ / A nd | Copyright (C) 2016 OpenFOAM Foundation + \\/ M anipulation | +------------------------------------------------------------------------------- +License + This file is part of OpenFOAM. + + OpenFOAM is free software: you can redistribute it and/or modify it + under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + OpenFOAM is distributed in the hope that it will be useful, but WITHOUT + ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + for more details. + + You should have received a copy of the GNU General Public License + along with OpenFOAM. If not, see . + +\*---------------------------------------------------------------------------*/ + +// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // + +// * * * * * * * * * * * * * Private Member Functions * * * * * * * * * * * // + + +// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * // + + +// * * * * * * * * * * * * * * * * Destructor * * * * * * * * * * * * * * * // + + +// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * // + + +// * * * * * * * * * * * * * * * Member Operators * * * * * * * * * * * * * // + + +// * * * * * * * * * * * * * * * Friend Functions * * * * * * * * * * * * * // + + +// * * * * * * * * * * * * * * * Friend Operators * * * * * * * * * * * * * // + + +// * * * * * * * * * * * * * * IOstream Operators * * * * * * * * * * * * * // + + +// * * * * * * * * * * * * * * * Ostream Operator * * * * * * * * * * * * * // + + +// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // + + +// ************************************************************************* // diff --git a/FlameStructure/FlameStructureIO.C b/FlameStructure/FlameStructureIO.C new file mode 100644 index 0000000..75b6748 --- /dev/null +++ b/FlameStructure/FlameStructureIO.C @@ -0,0 +1,72 @@ +/*---------------------------------------------------------------------------*\ + ========= | + \\ / F ield | OpenFOAM: The Open Source CFD Toolbox + \\ / O peration | + \\ / A nd | Copyright (C) 2016 OpenFOAM Foundation + \\/ M anipulation | +------------------------------------------------------------------------------- +License + This file is part of OpenFOAM. + + OpenFOAM is free software: you can redistribute it and/or modify it + under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + OpenFOAM is distributed in the hope that it will be useful, but WITHOUT + ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + for more details. + + You should have received a copy of the GNU General Public License + along with OpenFOAM. If not, see . + +\*---------------------------------------------------------------------------*/ + +#include "FlameStructure.H" +#include "IOstreams.H" + +// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * // + + /* +Foam::SLFM::FlameStructure::FlameStructure(Istream& is) +: + base1(is), + base2(is), + member1(is), + member2(is) +{ + // Check state of Istream + is.check("Foam::SLFM::FlameStructure::FlameStructure(Foam::Istream&)"); +} + */ + + +// * * * * * * * * * * * * * * * IOstream Operators * * * * * * * * * * * * // + +Foam::Istream& Foam::operator>>(Istream& is, SLFM::FlameStructure&) +{ + // Check state of Istream + is.check + ( + "Foam::Istream& Foam::operator>>(Foam::Istream&, Foam::SLFM::FlameStructure&)" + ); + + return is; +} + + +Foam::Ostream& Foam::operator<<(Ostream& os, const SLFM::FlameStructure&) +{ + // Check state of Ostream + os.check + ( + "Foam::Ostream& Foam::operator<<(Foam::Ostream&, " + "const Foam::SLFM::FlameStructure&)" + ); + + return os; +} + + +// ************************************************************************* // diff --git a/Make/files b/Make/files new file mode 100644 index 0000000..3349e8d --- /dev/null +++ b/Make/files @@ -0,0 +1,17 @@ +FlameStructure/FlameStructure.C +FlameStructure/FlameStructureIO.C + +./AMC/AMC.C + +./BetaFunction/BetaFunction.C +./BetaFunction/BetaFunctionIO.C + +./BetaGrid/BetaGrid.C +./BetaGrid/BetaGridIO.C + +./BetaIntegrator/BetaIntegrator.C +./BetaIntegrator/BetaIntegratorIO.C + +SLFMFoam.C + +EXE = $(FOAM_APPBIN)/SLFMFoam diff --git a/Make/options b/Make/options new file mode 100644 index 0000000..3e21a2b --- /dev/null +++ b/Make/options @@ -0,0 +1,34 @@ +EXE_INC = \ + -I. \ + -I./AMC \ + -I./BetaFunction \ + -I./BetaGrid \ + -I./BetaIntegrator \ + -I$(LIB_SRC)/finiteVolume/lnInclude \ + -I$(LIB_SRC)/meshTools/lnInclude \ + -I$(LIB_SRC)/TurbulenceModels/turbulenceModels/lnInclude \ + -I$(LIB_SRC)/TurbulenceModels/compressible/lnInclude \ + -I$(LIB_SRC)/thermophysicalModels/specie/lnInclude \ + -I$(LIB_SRC)/transportModels/compressible/lnInclude \ + -I$(LIB_SRC)/thermophysicalModels/basic/lnInclude \ + -I$(LIB_SRC)/thermophysicalModels/reactionThermo/lnInclude \ + -I$(LIB_SRC)/thermophysicalModels/chemistryModel/lnInclude \ + -I$(LIB_SRC)/ODE/lnInclude \ + -I$(LIB_SRC)/combustionModels/lnInclude \ + -I$(LIB_SRC)/sampling/lnInclude + + +EXE_LIBS = \ + -lfiniteVolume \ + -lmeshTools \ + -lturbulenceModels \ + -lcompressibleTurbulenceModels \ + -lspecie \ + -lcompressibleTransportModels \ + -lfluidThermophysicalModels \ + -lreactionThermophysicalModels \ + -lchemistryModel \ + -lODE \ + -lcombustionModels \ + -lfvOptions \ + -lsampling diff --git a/Mixturefraction.H b/Mixturefraction.H new file mode 100644 index 0000000..b085950 --- /dev/null +++ b/Mixturefraction.H @@ -0,0 +1,10 @@ +// mixture fraction equation +fvScalarMatrix mfEqn +( + fvm::div(phi, mf) + - fvm::laplacian((1/Sc)*turbulence->mut(), mf) //let 1/Sc = 1.47 +); + +mfEqn.relax(); + +mfEqn.solve(); diff --git a/MixturefractionVar.H b/MixturefractionVar.H new file mode 100644 index 0000000..bcd78f1 --- /dev/null +++ b/MixturefractionVar.H @@ -0,0 +1,17 @@ +//mixture fraction variance equation +//cf) mfVar should not be ZERO +SDR = turbulence->epsilon() * mfVar / turbulence->k(); +volVectorField Gradmf = fvc::grad(mf); + +fvScalarMatrix mfVarEqn +( + fvm::div(phi, mfVar) + - fvm::laplacian((1/Sc) * turbulence->mut(), mfVar) + == + 2 * ((1/Sc) * turbulence->mut()) * (Gradmf & Gradmf) + - 2 * rho * SDR +); + +mfVarEqn.relax(); + +mfVarEqn.solve(); diff --git a/SLFMFoam.C b/SLFMFoam.C new file mode 100644 index 0000000..8d1d489 --- /dev/null +++ b/SLFMFoam.C @@ -0,0 +1,118 @@ +/*---------------------------------------------------------------------------*\ + ========= | + \\ / F ield | OpenFOAM: The Open Source CFD Toolbox + \\ / O peration | + \\ / A nd | Copyright (C) 2013-2016 OpenFOAM Foundation + \\/ M anipulation | +------------------------------------------------------------------------------- +License + This file is part of OpenFOAM. + + OpenFOAM is free software: you can redistribute it and/or modify it + under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + OpenFOAM is distributed in the hope that it will be useful, but WITHOUT + ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + for more details. + + You should have received a copy of the GNU General Public License + along with OpenFOAM. If not, see . + +Application + SLFMFoam + +Description + Steady Laminar Flamelet Model(SLFM) solver for turbulent combustion. SLFM + assumes a turbulent flame composed of thin stretched laminar flamelets. + Each flamelet library is generated by external program and imported by + the solver. + +References + A.Y. Klimenko, R.W. Bilger, Progress in Energy and Combustion Science 25 (1999) 595-687 + N. Peters, Turbulent Combustion, Cambridge University Press (2000) + +Contact + POSTECH combustion lab. + huh@postech.ac.kr + +\*---------------------------------------------------------------------------*/ + +#include "fvCFD.H" +#include "turbulentFluidThermoModel.H" +#include "rhoCombustionModel.H" +#include "fvOptions.H" +#include "simpleControl.H" +#include "FlameStructure/FlameStructure.H" +#include "interpolateXY.H" + +#include "AMC.H" +#include "BetaFunction.H" +#include "BetaGrid.H" +#include "BetaIntegrator.H" +// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // + +int main(int argc, char *argv[]) +{ + #include "postProcess.H" + + #include "setRootCase.H" + #include "createTime.H" + #include "createMesh.H" + #include "createControl.H" + #include "createFields.H" + #include "createFieldRefs.H" + #include "createFvOptions.H" + #include "initContinuityErrs.H" + + turbulence->validate(); + + //SLFM + Info<<"Read SLFM library"<correct(); + + if (runTime.write()) + { + #include "updateYi.H" //update species + } + + Info<< "ExecutionTime = " << runTime.elapsedCpuTime() << " s" + << " ClockTime = " << runTime.elapsedClockTime() << " s" + << nl << endl; + } + + Info<< "End\n" << endl; + + return 0; +} + + +// ************************************************************************* // diff --git a/UEqn.H b/UEqn.H new file mode 100644 index 0000000..733ff92 --- /dev/null +++ b/UEqn.H @@ -0,0 +1,20 @@ + MRF.correctBoundaryVelocity(U); + + tmp tUEqn + ( + fvm::div(phi, U) + + MRF.DDt(rho, U) + + turbulence->divDevRhoReff(U) + == + rho()*g + + fvOptions(rho, U) + ); + fvVectorMatrix& UEqn = tUEqn.ref(); + + UEqn.relax(); + + fvOptions.constrain(UEqn); + + solve(UEqn == -fvc::grad(p)); + + fvOptions.correct(U); diff --git a/createFieldRefs.H b/createFieldRefs.H new file mode 100644 index 0000000..6600f4d --- /dev/null +++ b/createFieldRefs.H @@ -0,0 +1,2 @@ +const volScalarField& psi = thermo.psi(); +//const volScalarField& T = thermo.T(); diff --git a/createFields.H b/createFields.H new file mode 100644 index 0000000..ea1c5ac --- /dev/null +++ b/createFields.H @@ -0,0 +1,374 @@ +#include "readGravitationalAcceleration.H" + +Info<< "Creating combustion model\n" << endl; + +autoPtr combustion +( + combustionModels::rhoCombustionModel::New(mesh) +); + +rhoReactionThermo& thermo = combustion->thermo(); +thermo.validate(args.executable(), "h", "e"); + +basicSpecieMixture& composition = thermo.composition(); +PtrList& Y = composition.Y(); + +const word inertSpecie(thermo.lookup("inertSpecie")); + +if (!composition.contains(inertSpecie)) +{ + FatalErrorInFunction + << "Specified inert specie '" << inertSpecie << "' not found in " + << "species list. Available species:" << composition.species() + << exit(FatalError); +} + +volScalarField& p = thermo.p(); +volScalarField& T = thermo.T(); + +wordList rhoBoundaryTypes +( + T.boundaryField().size(), + zeroGradientFvPatchScalarField::typeName +); + +forAll(composition.Y(inertSpecie).boundaryField(), patchi) +{ + rhoBoundaryTypes[patchi] + = composition.Y(inertSpecie).boundaryField()[patchi].type(); +} + + +volScalarField rho +( + IOobject + ( + "rho", + runTime.timeName(), + mesh, + IOobject::NO_READ, + IOobject::AUTO_WRITE + ), + thermo.rho(), + rhoBoundaryTypes +); + +Info<< "\nReading field U\n" << endl; +volVectorField U +( + IOobject + ( + "U", + runTime.timeName(), + mesh, + IOobject::MUST_READ, + IOobject::AUTO_WRITE + ), + mesh +); + +#include "compressibleCreatePhi.H" + +mesh.setFluxRequired(p.name()); + +dimensionedScalar rhoMax +( + dimensionedScalar::lookupOrDefault + ( + "rhoMax", + simple.dict(), + dimDensity, + GREAT + ) +); + +dimensionedScalar rhoMin +( + dimensionedScalar::lookupOrDefault + ( + "rhoMin", + simple.dict(), + dimDensity, + 0 + ) +); + +Info<< "Creating turbulence model\n" << endl; +autoPtr turbulence +( + compressible::turbulenceModel::New + ( + rho, + U, + phi, + thermo + ) +); + +// Set the turbulence into the combustion model +combustion->setTurbulence(turbulence()); + +Info<< "Creating multi-variate interpolation scheme\n" << endl; +multivariateSurfaceInterpolationScheme::fieldTable fields; + +forAll(Y, i) +{ + fields.add(Y[i]); +} +fields.add(thermo.he()); + + +// SLFM-related fields + +Info<<"Creating field mf, mfVar, SDR\n"< Neta(etamax); + +for(label j=0 ; j scalarFieldArray1d; +typedef List scalarFieldArray2d; +typedef List scalarFieldArray3d; + +SLFM::FlameStructure slfmLibrary(runTime.constant()/NstFolder, NstList, etaGrid, composition.species()); + +scalarFieldArray2d& Y_SLFM (slfmLibrary.Y()); +scalarFieldArray2d& W_SLFM (slfmLibrary.W()); +scalarFieldArray1d& T_SLFM (slfmLibrary.T()); +scalarFieldArray1d& Q_SLFM (slfmLibrary.Q()); +scalarFieldArray1d& rho_SLFM (slfmLibrary.rho()); +scalarFieldArray1d& h_SLFM (slfmLibrary.h()); +scalarFieldArray1d& Rgas_SLFM (slfmLibrary.Rgas()); + +for(label n=0 ; n stoi) +upperSum = Foam::pow(stretchFac,upperN)-1.0; +upperSum = upperSum/(stretchFac-1.0); + +//summation of geometric progression (eta < stoi) +lowerSum = Foam::pow(stretchFac,lowerN)-1.0; +lowerSum = lowerSum/(stretchFac-1.0); + +//set reference delta eta +upperDelta = (1.0-stoiMF)/upperSum; +lowerDelta = stoiMF/lowerSum; + +//set boundary and stoichiometric value of eta +etaValue[0] = 0.0; +etaValue[lowerN] = stoiMF; +etaValue.last() = 1.0; + +//set internal value of eta (eta > stoi) +for(label j=0 ; j etaValue[etamax-2]) + { + jl = etamax-2; + jh = etamax-1; + } + else + { + jl = label( interpolateXY(mf[cellI], etaValue, etaIndex) ); + jh = jl+1; + } + jfac = max(0.0, (mf[cellI]-etaValue[jl])/(etaValue[jh]-etaValue[jl])); + + //find var-index, factor + scalar scaledVar = min(0.99999, mfVar[cellI]/(mf[cellI]*(1.0-mf[cellI])+SMALL)); + if(scaledVar < varValue[1]) + { + vl = 0; + vh = 1; + } + else if(scaledVar > varValue[NVar-1]) + { + vl = NVar-1; + vh = NVar; + } + else + { + vl = label( interpolateXY(scaledVar, varValue, varIndex) ); + vh = vl+1; + } + vfac = max(0.0, (scaledVar-varValue[vl])/(varValue[vh]-varValue[vl])); + + + //Bi-linear interpolation on j and v + //Numerical recipes, 2nd Ed. p.117 + C1coeff + = C1table[jl][vl]*(1-jfac)*(1-vfac) + + C1table[jh][vl]*(jfac)*(1-vfac) + + C1table[jh][vh]*(jfac)*(vfac) + + C1table[jl][vh]*(1-jfac)*(vfac); + + jlc[cellI] = jl; + jhc[cellI] = jh; + jfc[cellI] = jfac; + vlc[cellI] = vl; + vhc[cellI] = vh; + vfc[cellI] = vfac; + + + scalar Coeff = AMCcoeff[lowerN]; + + if (Equilibrium == true) + { + Neta[lowerN][cellI] = 0; //Equilibrium + } + else + { + Neta[lowerN][cellI] = SDR[cellI]*Coeff*C1coeff; //CSDR at stoichiometic m.f. + } +} + + diff --git a/setVarSpace.H b/setVarSpace.H new file mode 100644 index 0000000..d0413aa --- /dev/null +++ b/setVarSpace.H @@ -0,0 +1,23 @@ +//set normalized variance space +{ + scalar sum(0), del(0), fac(1.075); + + sum = Foam::pow(fac,NVar) - 1.0; + sum = sum/(fac-1.0); + + del = 1.0/sum; + + varValue[0] = 0.0; + varValue[NVar] = 1.0; + + for(label v=0 ; v NstList[NstList.size()-2]) + { + nhc[cellI] = NstList.size()-2; //just before extinction + nfc[cellI] = 1; + } + else + { + nlc[cellI] = label( interpolateXY(Nst, NstList, NstIndex) ); + nhc[cellI] = nlc[cellI]+1; + nfc[cellI] = (Nst-NstList[nlc[cellI]]) + /(NstList[nhc[cellI]]-NstList[nlc[cellI]]); + } + + //update Favre mean temp. and rho(=1/RT) + scalar jl = jlc[cellI], jh = jhc[cellI]; + scalar vl = vlc[cellI], vh = vhc[cellI]; + scalar nl = nlc[cellI], nh = nhc[cellI]; + scalar jfac = jfc[cellI], vfac = vfc[cellI], nfac = nfc[cellI]; + + scalar T00 = Ttable[jl][vl][nl]*(1-jfac)+Ttable[jh][vl][nl]*jfac; + scalar T01 = Ttable[jl][vl][nh]*(1-jfac)+Ttable[jh][vl][nh]*jfac; + scalar T10 = Ttable[jl][vh][nl]*(1-jfac)+Ttable[jh][vh][nl]*jfac; + scalar T11 = Ttable[jl][vh][nh]*(1-jfac)+Ttable[jh][vh][nh]*jfac; + + scalar T0 = T00*(1-vfac)+T10*vfac; + scalar T1 = T01*(1-vfac)+T11*vfac; + + T[cellI] = T0*(1-nfac)+T1*nfac; + + scalar R00 = Rtable[jl][vl][nl]*(1-jfac)+Rtable[jh][vl][nl]*jfac; + scalar R01 = Rtable[jl][vl][nh]*(1-jfac)+Rtable[jh][vl][nh]*jfac; + scalar R10 = Rtable[jl][vh][nl]*(1-jfac)+Rtable[jh][vh][nl]*jfac; + scalar R11 = Rtable[jl][vh][nh]*(1-jfac)+Rtable[jh][vh][nh]*jfac; + + scalar R0 = R00*(1-vfac)+R10*vfac; + scalar R1 = R01*(1-vfac)+R11*vfac; + + scalar Rgas = R0*(1-nfac)+R1*nfac; + rho[cellI] = p[cellI]/(Rgas*T[cellI]); +} + +//correct processor boundary value of T and rho +T.correctBoundaryConditions(); +rho.correctBoundaryConditions(); + diff --git a/updateYi.H b/updateYi.H new file mode 100644 index 0000000..09a38c7 --- /dev/null +++ b/updateYi.H @@ -0,0 +1,56 @@ +//force the saving of the old-time values +//important!! + +forAll(rho, cellI) +{ + scalar& Nst = Neta[lowerN][cellI]; + + //find Nst index + if(Nst < NstList.first()) + { + nlc[cellI] = 0; + nfc[cellI] = 0; + } + else if(Nst > NstList[NstList.size()-2]) + { + nhc[cellI] = NstList.size()-2; //just before extinction + nfc[cellI] = 1; + } + else + { + nlc[cellI] = label( interpolateXY(Nst, NstList, NstIndex) ); + nhc[cellI] = nlc[cellI]+1; + nfc[cellI] = (Nst-NstList[nlc[cellI]]) + /(NstList[nhc[cellI]]-NstList[nlc[cellI]]); + } + + //update Favre mean temp. and rho(=1/RT) + scalar jl = jlc[cellI], jh = jhc[cellI]; + scalar vl = vlc[cellI], vh = vhc[cellI]; + scalar nl = nlc[cellI], nh = nhc[cellI]; + scalar jfac = jfc[cellI], vfac = vfc[cellI], nfac = nfc[cellI]; + + + forAll(Y, yi) + { + scalar y00 = Ytable[yi][jl][vl][nl]*(1-jfac)+Ytable[yi][jh][vl][nl]*jfac; + scalar y01 = Ytable[yi][jl][vl][nh]*(1-jfac)+Ytable[yi][jh][vl][nh]*jfac; + scalar y10 = Ytable[yi][jl][vh][nl]*(1-jfac)+Ytable[yi][jh][vh][nl]*jfac; + scalar y11 = Ytable[yi][jl][vh][nh]*(1-jfac)+Ytable[yi][jh][vh][nh]*jfac; + + scalar y0 = y00*(1-vfac)+y10*vfac; + scalar y1 = y01*(1-vfac)+y11*vfac; + + scalar ygas = y0*(1-nfac)+y1*nfac; + + Y[yi][cellI] = ygas; + } +} + +//correct processor boundary value of T and rho +forAll(Y, yi) +{ + Y[yi].correctBoundaryConditions(); +} + +