Initial commit

applications/solvers/combustion/chemFoam/hEqn.H

+{
+    volScalarField& h = thermo.he();
+
+    if (constProp == "volume")
+    {
+        h[0] = u0 + p[0]/rho[0] + integratedHeat;
+    }
+    else
+    {
+        h[0] = h0 + integratedHeat;
+    }
+
+    thermo.correct();
+}

applications/solvers/combustion/chemFoam/output.H

+    runTime.write();
+
+    Info<< "Qdot = " << Qdot
+        << ", T = " << thermo.T()[0]
+        << ", p = " << thermo.p()[0]
+        << ", " << Y[0].name() << " = " << Y[0][0]
+        << endl;
+
+    post<< runTime.value() << token::TAB << thermo.T()[0] << token::TAB
+        << thermo.p()[0] << endl;

applications/solvers/combustion/chemFoam/pEqn.H

+{
+    rho = thermo.rho();
+    if (constProp == "volume")
+    {
+        scalar invW = 0.0;
+        forAll(Y, i)
+        {
+            invW += Y[i][0]/specieData[i].W();
+        }
+
+        Rspecific[0] = 1000.0*constant::physicoChemical::R.value()*invW;
+
+        p[0] = rho0*Rspecific[0]*thermo.T()[0];
+        rho[0] = rho0;
+    }
+}

applications/solvers/combustion/chemFoam/readControls.H

+runTime.controlDict().readEntry("adjustTimeStep", adjustTimeStep);
+
+runTime.controlDict().readEntry("maxDeltaT", maxDeltaT);

applications/solvers/combustion/chemFoam/readInitialConditions.H

+    word constProp(initialConditions.get<word>("constantProperty"));
+    if (constProp != "pressure" && constProp != "volume")
+    {
+        FatalError << "in initialConditions, unknown constantProperty type "
+            << constProp << nl << " Valid types are: pressure volume."
+            << abort(FatalError);
+    }
+
+    word fractionBasis(initialConditions.get<word>("fractionBasis"));
+    if (fractionBasis != "mass" && fractionBasis != "mole")
+    {
+        FatalError << "in initialConditions, unknown fractionBasis type " << nl
+            << "Valid types are: mass or mole."
+            << fractionBasis << abort(FatalError);
+    }
+
+    label nSpecie = Y.size();
+    PtrList<gasHThermoPhysics> specieData(Y.size());
+    forAll(specieData, i)
+    {
+        specieData.set
+        (
+            i,
+            new gasHThermoPhysics
+            (
+                dynamic_cast<const reactingMixture<gasHThermoPhysics>&>
+                    (thermo).speciesData()[i]
+            )
+        );
+    }
+
+    scalarList Y0(nSpecie, Zero);
+    scalarList X0(nSpecie, Zero);
+
+    dictionary fractions(initialConditions.subDict("fractions"));
+    if (fractionBasis == "mole")
+    {
+        forAll(Y, i)
+        {
+            fractions.readIfPresent(Y[i].name(), X0[i]);
+        }
+
+        scalar mw = 0.0;
+        const scalar mTot = sum(X0);
+        forAll(Y, i)
+        {
+            X0[i] /= mTot;
+            mw += specieData[i].W()*X0[i];
+        }
+
+        forAll(Y, i)
+        {
+            Y0[i] = X0[i]*specieData[i].W()/mw;
+        }
+    }
+    else  // mass fraction
+    {
+        forAll(Y, i)
+        {
+            fractions.readIfPresent(Y[i].name(), Y0[i]);
+        }
+
+        scalar invW = 0.0;
+        const scalar mTot = sum(Y0);
+        forAll(Y, i)
+        {
+            Y0[i] /= mTot;
+            invW += Y0[i]/specieData[i].W();
+        }
+        const scalar mw = 1.0/invW;
+
+        forAll(Y, i)
+        {
+            X0[i] = Y0[i]*mw/specieData[i].W();
+        }
+    }
+
+    scalar h0 = 0.0;
+    forAll(Y, i)
+    {
+        Y[i] = Y0[i];
+        h0 += Y0[i]*specieData[i].Hs(p[0], T0);
+    }
+
+    thermo.he() = dimensionedScalar("h", dimEnergy/dimMass, h0);
+    thermo.correct();
+
+    rho = thermo.rho();
+    scalar rho0 = rho[0];
+    scalar u0 = h0 - p0/rho0;
+    scalar R0 = p0/(rho0*T0);
+    Rspecific[0] = R0;
+
+    scalar integratedHeat = 0.0;
+
+    Info << constProp << " will be held constant." << nl
+        << " p   = " << p[0] << " [Pa]" << nl
+        << " T   = " << thermo.T()[0] << " [K] " << nl
+        << " rho = " << rho[0] << " [kg/m3]" << nl
+        << endl;

applications/solvers/combustion/chemFoam/setDeltaT.H

+if (adjustTimeStep)
+{
+    runTime.setDeltaT(min(dtChem, maxDeltaT));
+    Info<< "deltaT = " <<  runTime.deltaT().value() << endl;
+}

applications/solvers/combustion/chemFoam/solveChemistry.H

+dtChem = chemistry.solve(runTime.deltaT().value());
+scalar Qdot = chemistry.Qdot()()[0]/rho[0];
+integratedHeat += Qdot*runTime.deltaT().value();

applications/solvers/combustion/coldEngineFoam/Make/files

+coldEngineFoam.C
+
+EXE = $(FOAM_APPBIN)/coldEngineFoam

applications/solvers/combustion/coldEngineFoam/Make/options

+EXE_INC = \
+    -I../XiFoam/XiEngineFoam \
+    -I../XiFoam \
+    -I../../compressible/rhoPimpleFoam \
+    -I$(LIB_SRC)/finiteVolume/lnInclude \
+    -I$(LIB_SRC)/meshTools/lnInclude \
+    -I$(LIB_SRC)/sampling/lnInclude \
+    -I$(LIB_SRC)/engine/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)/TurbulenceModels/turbulenceModels/lnInclude \
+    -I$(LIB_SRC)/TurbulenceModels/compressible/lnInclude
+
+EXE_LIBS = \
+    -lfiniteVolume \
+    -lfvOptions \
+    -lmeshTools \
+    -lengine \
+    -lturbulenceModels \
+    -lcompressibleTurbulenceModels \
+    -lcompressibleTransportModels \
+    -lfluidThermophysicalModels \
+    -lspecie

applications/solvers/combustion/coldEngineFoam/coldEngineFoam.C

+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | www.openfoam.com
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+    Copyright (C) 2011-2017 OpenFOAM Foundation
+-------------------------------------------------------------------------------
+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 <http://www.gnu.org/licenses/>.
+
+Application
+    coldEngineFoam
+
+Group
+    grpCombustionSolvers grpMovingMeshSolvers
+
+Description
+    Solver for cold-flow in internal combustion engines.
+
+\*---------------------------------------------------------------------------*/
+
+#include "fvCFD.H"
+#include "engineTime.H"
+#include "engineMesh.H"
+#include "psiThermo.H"
+#include "turbulentFluidThermoModel.H"
+#include "OFstream.H"
+#include "fvOptions.H"
+#include "pimpleControl.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+int main(int argc, char *argv[])
+{
+    argList::addNote
+    (
+        "Solver for cold-flow in internal combustion engines."
+    );
+
+    #define CREATE_TIME createEngineTime.H
+    #define CREATE_MESH createEngineMesh.H
+    #include "postProcess.H"
+
+    #include "setRootCaseLists.H"
+    #include "createEngineTime.H"
+    #include "createEngineMesh.H"
+    #include "createControl.H"
+    #include "createFields.H"
+    #include "createFieldRefs.H"
+    #include "createRhoUf.H"
+    #include "initContinuityErrs.H"
+    #include "readEngineTimeControls.H"
+    #include "compressibleCourantNo.H"
+    #include "setInitialDeltaT.H"
+    #include "startSummary.H"
+
+    turbulence->validate();
+
+    // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+    Info<< "\nStarting time loop\n" << endl;
+
+    while (runTime.run())
+    {
+        #include "readEngineTimeControls.H"
+        #include "compressibleCourantNo.H"
+        #include "setDeltaT.H"
+
+        ++runTime;
+
+        Info<< "Engine time = " << runTime.theta() << runTime.unit()
+            << endl;
+
+        mesh.move();
+
+        #include "rhoEqn.H"
+
+        // --- Pressure-velocity PIMPLE corrector loop
+        while (pimple.loop())
+        {
+            #include "UEqn.H"
+
+            // --- Pressure corrector loop
+            while (pimple.correct())
+            {
+                #include "EEqn.H"
+                #include "pEqn.H"
+            }
+
+            if (pimple.turbCorr())
+            {
+                turbulence->correct();
+            }
+        }
+
+        runTime.write();
+
+        #include "logSummary.H"
+
+        runTime.printExecutionTime(Info);
+    }
+
+    Info<< "End\n" << endl;
+
+    return 0;
+}
+
+
+// ************************************************************************* //

applications/solvers/combustion/coldEngineFoam/createFieldRefs.H

+const volScalarField& psi = thermo.psi();
+const volScalarField& T = thermo.T();

applications/solvers/combustion/coldEngineFoam/createFields.H

+Info<< "Reading thermophysical properties\n" << endl;
+
+autoPtr<psiThermo> pThermo
+(
+    psiThermo::New(mesh)
+);
+psiThermo& thermo = pThermo();
+thermo.validate(args.executable(), "h", "e");
+
+volScalarField rho
+(
+    IOobject
+    (
+        "rho",
+        runTime.timeName(),
+        mesh,
+        IOobject::NO_READ,
+        IOobject::AUTO_WRITE
+    ),
+    thermo.rho()
+);
+
+volScalarField& p = thermo.p();
+
+Info<< "\nReading field U\n" << endl;
+volVectorField U
+(
+    IOobject
+    (
+        "U",
+        runTime.timeName(),
+        mesh,
+        IOobject::MUST_READ,
+        IOobject::AUTO_WRITE
+    ),
+    mesh
+);
+
+#include "compressibleCreatePhi.H"
+
+
+Info<< "Creating turbulence model\n" << endl;
+autoPtr<compressible::turbulenceModel> turbulence
+(
+    compressible::turbulenceModel::New
+    (
+        rho,
+        U,
+        phi,
+        thermo
+    )
+);
+
+#include "createDpdt.H"
+
+#include "createK.H"
+
+#include "createMRF.H"
+#include "createFvOptions.H"

applications/solvers/combustion/coldEngineFoam/logSummary.H

+{
+    const scalar meanp = p.weightedAverage(mesh.V()).value();
+    const scalar meanT = T.weightedAverage(mesh.V()).value();
+    const scalar meanup =
+        (sqrt((2.0/3.0)*turbulence->k()))().weightedAverage(mesh.V()).value();
+
+    if (Pstream::master())
+    {
+        Info<< "Mean pressure:" << meanp << endl;
+        Info<< "Mean temperature:" << meanT << endl;
+        Info<< "Mean u':" << meanup << endl;
+
+        logSummaryFile()
+            << runTime.theta() << tab
+            << meanp << tab
+            << meanT << tab
+            << meanup
+            << endl;
+    }
+}

applications/solvers/combustion/coldEngineFoam/startSummary.H

+Info<< "Total cylinder mass: " << fvc::domainIntegrate(rho).value() << endl;
+
+autoPtr<OFstream> logSummaryFile;
+
+if (Pstream::master())
+{
+    logSummaryFile.reset
+    (
+        new OFstream
+        (
+            runTime.globalPath()
+           /("logSummary." + runTime.timeName() + ".dat")
+        )
+    );
+
+    logSummaryFile()
+        << "# CA" << "      p" << "        T" << "       u'" << endl;
+}

applications/solvers/combustion/combustionSolversDoc.H

+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | www.openfoam.com
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+    Copyright (C) 2015 OpenFOAM Foundation
+-------------------------------------------------------------------------------
+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 <http://www.gnu.org/licenses/>.
+
+\defgroup grpCombustionSolvers Combustion solvers
+@{
+    \ingroup grpSolvers
+    This group contains combustion solvers.
+@}
+
+\*---------------------------------------------------------------------------*/

applications/solvers/combustion/fireFoam/Make/files

+fireFoam.C
+
+EXE = $(FOAM_APPBIN)/fireFoam

applications/solvers/combustion/fireFoam/Make/options

+EXE_INC = \
+    -I$(LIB_SRC)/finiteVolume/lnInclude \
+    -I$(LIB_SRC)/finiteArea/lnInclude \
+    -I${LIB_SRC}/meshTools/lnInclude \
+    -I${LIB_SRC}/sampling/lnInclude \
+    -I$(LIB_SRC)/TurbulenceModels/turbulenceModels/lnInclude \
+    -I$(LIB_SRC)/TurbulenceModels/compressible/lnInclude \
+    -I$(LIB_SRC)/lagrangian/distributionModels/lnInclude \
+    -I$(LIB_SRC)/thermophysicalModels/specie/lnInclude \
+    -I$(LIB_SRC)/thermophysicalModels/solid/lnInclude \
+    -I$(LIB_SRC)/transportModels/compressible/lnInclude \
+    -I$(LIB_SRC)/thermophysicalModels/basic/lnInclude \
+    -I$(LIB_SRC)/thermophysicalModels/solidThermo/lnInclude \
+    -I$(LIB_SRC)/thermophysicalModels/chemistryModel/lnInclude \
+    -I$(LIB_SRC)/thermophysicalModels/solidChemistryModel/lnInclude \
+    -I$(LIB_SRC)/combustionModels/lnInclude \
+    -I$(LIB_SRC)/thermophysicalModels/thermophysicalProperties/lnInclude \
+    -I$(LIB_SRC)/thermophysicalModels/reactionThermo/lnInclude \
+    -I$(LIB_SRC)/thermophysicalModels/SLGThermo/lnInclude \
+    -I$(LIB_SRC)/thermophysicalModels/radiation/lnInclude \
+    -I$(LIB_SRC)/regionModels/regionModel/lnInclude \
+    -I$(LIB_SRC)/regionModels/surfaceFilmModels/lnInclude \
+    -I$(LIB_SRC)/regionModels/pyrolysisModels/lnInclude \
+    -I$(LIB_SRC)/lagrangian/basic/lnInclude \
+    -I$(LIB_SRC)/lagrangian/intermediate/lnInclude \
+    -I$(LIB_SRC)/ODE/lnInclude \
+    -I$(LIB_SRC)/regionFaModels/lnInclude \
+    -I$(LIB_SRC)/faOptions/lnInclude
+
+EXE_LIBS = \
+    -lfiniteVolume \
+    -lfvOptions \
+    -lmeshTools \
+    -lsampling \
+    -lturbulenceModels \
+    -lcompressibleTurbulenceModels \
+    -lspecie \
+    -lcompressibleTransportModels \
+    -lfluidThermophysicalModels \
+    -lthermophysicalProperties \
+    -lreactionThermophysicalModels \
+    -lSLGThermo \
+    -lchemistryModel \
+    -lsolidChemistryModel \
+    -lcombustionModels \
+    -lregionModels \
+    -lradiationModels \
+    -lsurfaceFilmModels \
+    -lsurfaceFilmDerivedFvPatchFields \
+    -lpyrolysisModels \
+    -lregionCoupling \
+    -llagrangian \
+    -llagrangianIntermediate \
+    -llagrangianTurbulence \
+    -lODE \
+    -lregionFaModels \
+    -lfiniteArea \
+    -lfaOptions

applications/solvers/combustion/fireFoam/UEqn.H

+    MRF.correctBoundaryVelocity(U);
+
+    fvVectorMatrix UEqn
+    (
+        fvm::ddt(rho, U) + fvm::div(phi, U)
+      + MRF.DDt(rho, U)
+      + turbulence->divDevRhoReff(U)
+     ==
+        parcels.SU(U)
+      + fvOptions(rho, U)
+    );
+
+    UEqn.relax();
+
+    fvOptions.constrain(UEqn);
+
+    if (pimple.momentumPredictor())
+    {
+        solve
+        (
+            UEqn
+          ==
+            fvc::reconstruct
+            (
+                (
+                  - ghf*fvc::snGrad(rho)
+                  - fvc::snGrad(p_rgh)
+                )*mesh.magSf()
+            )
+        );
+
+        fvOptions.correct(U);
+        K = 0.5*magSqr(U);
+    }

applications/solvers/combustion/fireFoam/YEEqn.H

+tmp<fv::convectionScheme<scalar>> mvConvection
+(
+    fv::convectionScheme<scalar>::New
+    (
+        mesh,
+        fields,
+        phi,
+        mesh.divScheme("div(phi,Yi_h)")
+    )
+);
+{
+    combustion->correct();
+    Qdot = combustion->Qdot();
+    volScalarField Yt(0.0*Y[0]);
+
+    forAll(Y, i)
+    {
+        if (i != inertIndex && composition.active(i))
+        {
+            volScalarField& Yi = Y[i];
+
+            fvScalarMatrix YiEqn
+            (
+                fvm::ddt(rho, Yi)
+              + mvConvection->fvmDiv(phi, Yi)
+              - fvm::laplacian(turbulence->alphaEff(), Yi)
+              ==
+                parcels.SYi(i, Yi)
+              + surfaceFilm.Srho(i)
+              + combustion->R(Yi)
+              + fvOptions(rho, Yi)
+            );
+
+            YiEqn.relax();
+
+            fvOptions.constrain(YiEqn);
+
+            YiEqn.solve(mesh.solver("Yi"));
+
+            fvOptions.correct(Yi);
+
+            Yi.max(0.0);
+            Yt += Yi;
+        }
+    }
+
+    Y[inertIndex] = scalar(1) - Yt;
+    Y[inertIndex].max(0.0);
+
+    radiation->correct();
+
+    volScalarField& he = thermo.he();
+
+    fvScalarMatrix EEqn
+    (
+        fvm::ddt(rho, he) + mvConvection->fvmDiv(phi, he)
+      + fvc::ddt(rho, K) + fvc::div(phi, K)
+      + (
+            he.name() == "e"
+          ? fvc::div
+            (
+                fvc::absolute(phi/fvc::interpolate(rho), U),
+                p,
+                "div(phiv,p)"
+            )
+          : -dpdt
+        )
+      - fvm::laplacian(turbulence->alphaEff(), he)
+     ==
+        Qdot
+      + radiation->Sh(thermo, he)
+      + parcels.Sh(he)
+      + surfaceFilm.Sh()
+      + fvOptions(rho, he)
+    );
+
+    EEqn.relax();
+
+    fvOptions.constrain(EEqn);
+
+    EEqn.solve();
+
+    fvOptions.correct(he);
+
+    thermo.correct();
+
+    Info<< "min/max(T) = "
+        << min(T).value() << ", " << max(T).value() << endl;
+}

applications/solvers/combustion/fireFoam/createClouds.H

+Info<< "\nConstructing reacting cloud" << endl;
+basicReactingCloud parcels
+(
+    "reactingCloud1",
+    rho,
+    U,
+    g,
+    slgThermo
+);