Merge branch 'master' of /home/dm4/OpenFOAM/OpenFOAM-dev

Conflicts:
	src/lagrangian/dieselSpray/spray/findInjectorCell.H

applications/solvers/combustion/dieselEngineFoam/Make/files

-dieselEngineFoam.C
-
-EXE = $(FOAM_APPBIN)/dieselEngineFoam

applications/solvers/combustion/dieselEngineFoam/UEqn.H

-    fvVectorMatrix UEqn
-    (
-        fvm::ddt(rho, U)
-      + fvm::div(phi, U)
-      + turbulence->divDevRhoReff(U)
-     ==
-        rho*g
-      + dieselSpray.momentumSource()
-    );
-
-    if (pimple.momentumPredictor())
-    {
-        solve(UEqn == -fvc::grad(p));
-    }

applications/solvers/combustion/dieselEngineFoam/YEqn.H

-tmp<fv::convectionScheme<scalar> > mvConvection
-(
-    fv::convectionScheme<scalar>::New
-    (
-        mesh,
-        fields,
-        phi,
-        mesh.divScheme("div(phi,Yi_h)")
-    )
-);
-
-{
-    combustion->correct();
-    dQ = combustion->dQ();
-    label inertIndex = -1;
-    volScalarField Yt(0.0*Y[0]);
-
-    forAll(Y, i)
-    {
-        if (Y[i].name() != inertSpecie)
-        {
-            volScalarField& Yi = Y[i];
-
-            fvScalarMatrix YiEqn
-            (
-                fvm::ddt(rho, Yi)
-              + mvConvection->fvmDiv(phi, Yi)
-              - fvm::laplacian(turbulence->muEff(), Yi)
-              ==
-                dieselSpray.evaporationSource(i)
-              + combustion->R(Yi)
-            );
-
-            YiEqn.relax();
-            YiEqn.solve(mesh.solver("Yi"));
-
-            Yi.max(0.0);
-            Yt += Yi;
-        }
-        else
-        {
-            inertIndex = i;
-        }
-    }
-
-    Y[inertIndex] = scalar(1) - Yt;
-    Y[inertIndex].max(0.0);
-}

applications/solvers/combustion/dieselEngineFoam/createFields.H

-Info<< "Creating combustion model\n" << endl;
-
-autoPtr<combustionModels::psiChemistryCombustionModel> combustion
-(
-    combustionModels::psiChemistryCombustionModel::New
-    (
-        mesh
-    )
-);
-
-psiChemistryModel& chemistry = combustion->pChemistry();
-
-hsCombustionThermo& thermo = chemistry.thermo();
-
-basicMultiComponentMixture& composition = thermo.composition();
-PtrList<volScalarField>& Y = composition.Y();
-
-word inertSpecie(thermo.lookup("inertSpecie"));
-
-if (!composition.contains(inertSpecie))
-{
-    FatalErrorIn(args.executable())
-        << "Specified inert specie '" << inertSpecie << "' not found in "
-        << "species list. Available species:" << composition.species()
-        << exit(FatalError);
-}
-
-volScalarField rho
-(
-    IOobject
-    (
-        "rho",
-        runTime.timeName(),
-        mesh
-    ),
-    thermo.rho()
-);
-
-Info<< "Reading field U\n" << endl;
-volVectorField U
-(
-    IOobject
-    (
-        "U",
-        runTime.timeName(),
-        mesh,
-        IOobject::MUST_READ,
-        IOobject::AUTO_WRITE
-    ),
-    mesh
-);
-
-
-volScalarField& p = thermo.p();
-const volScalarField& psi = thermo.psi();
-const volScalarField& T = thermo.T();
-volScalarField& hs = thermo.hs();
-
-
-#include "compressibleCreatePhi.H"
-
-Info << "Creating turbulence model.\n" << nl;
-autoPtr<compressible::turbulenceModel> turbulence
-(
-    compressible::turbulenceModel::New
-    (
-        rho,
-        U,
-        phi,
-        thermo
-    )
-);
-
-// Set the turbulence into the combustion model
-combustion->setTurbulence(turbulence());
-
-Info<< "Creating field DpDt\n" << endl;
-volScalarField DpDt
-(
-    fvc::DDt(surfaceScalarField("phiU", phi/fvc::interpolate(rho)), p)
-);
-
-
-multivariateSurfaceInterpolationScheme<scalar>::fieldTable fields;
-
-forAll(Y, i)
-{
-    fields.add(Y[i]);
-}
-fields.add(hs);
-
-volScalarField dQ
-(
-    IOobject
-    (
-        "dQ",
-        runTime.timeName(),
-        mesh,
-        IOobject::NO_READ,
-        IOobject::AUTO_WRITE
-    ),
-    mesh,
-    dimensionedScalar("dQ", dimEnergy/dimTime, 0.0)
-);

applications/solvers/combustion/dieselEngineFoam/createSpray.H

-Info << "Constructing Spray" << endl;
-
-PtrList<gasThermoPhysics> gasProperties(Y.size());
-forAll(gasProperties, i)
-{
-    gasProperties.set
-    (
-        i,
-        new gasThermoPhysics
-        (
-            dynamic_cast<const reactingMixture<gasThermoPhysics>&>
-                (thermo).speciesData()[i]
-        )
-    );
-}
-
-spray dieselSpray
-(
-    U,
-    rho,
-    p,
-    T,
-    composition,
-    gasProperties,
-    thermo,
-    g
-);
-
-scalar gasMass0 = fvc::domainIntegrate(rho).value();
-
-if (dieselSpray.twoD())
-{
-    gasMass0 *= constant::mathematical::twoPi/dieselSpray.angleOfWedge();
-}
-
-gasMass0 -=
-    dieselSpray.injectedMass(runTime.value()) - dieselSpray.liquidMass();

applications/solvers/combustion/dieselEngineFoam/hsEqn.H

-{
-    fvScalarMatrix hsEqn
-    (
-        fvm::ddt(rho, hs)
-      + mvConvection->fvmDiv(phi, hs)
-      - fvm::laplacian(turbulence->alphaEff(), hs)
-     ==
-        DpDt
-      + combustion->Sh()
-      + dieselSpray.heatTransferSource()()
-
-    );
-
-    hsEqn.relax();
-    hsEqn.solve();
-
-    thermo.correct();
-
-    Info<< "min/max(T) = "
-        << min(T).value() << ", " << max(T).value() << endl;
-}

applications/solvers/combustion/dieselEngineFoam/pEqn.H

-rho = thermo.rho();
-
-volScalarField A(UEqn.A());
-U = UEqn.H()/A;
-
-if (pimple.transonic())
-{
-    surfaceScalarField phid
-    (
-        "phid",
-        fvc::interpolate(psi)
-       *((fvc::interpolate(U) & mesh.Sf()) - fvc::meshPhi(rho, U))
-    );
-
-    while (pimple.correctNonOrthogonal())
-    {
-        fvScalarMatrix pEqn
-        (
-            fvm::ddt(psi, p)
-          + fvm::div(phid, p)
-          - fvm::laplacian(rho/A, p)
-         ==
-            Sevap
-        );
-
-        pEqn.solve(mesh.solver(p.select(pimple.finalInnerIter())));
-
-        if (pimple.finalNonOrthogonalIter())
-        {
-            phi == pEqn.flux();
-        }
-    }
-}
-else
-{
-    phi = fvc::interpolate(rho)
-         *((fvc::interpolate(U) & mesh.Sf()) - fvc::meshPhi(rho, U));
-
-    while (pimple.correctNonOrthogonal())
-    {
-        fvScalarMatrix pEqn
-        (
-            fvm::ddt(psi, p)
-          + fvc::div(phi)
-          - fvm::laplacian(rho/A, p)
-         ==
-            Sevap
-        );
-
-        pEqn.solve(mesh.solver(p.select(pimple.finalInnerIter())));
-
-        if (pimple.finalNonOrthogonalIter())
-        {
-            phi += pEqn.flux();
-        }
-    }
-}
-
-#include "rhoEqn.H"
-#include "compressibleContinuityErrs.H"
-
-U -= fvc::grad(p)/A;
-U.correctBoundaryConditions();
-
-DpDt = fvc::DDt(surfaceScalarField("phiU", phi/fvc::interpolate(rho)), p);

applications/solvers/combustion/dieselEngineFoam/rhoEqn.H

-/*---------------------------------------------------------------------------*\
-  =========                 |
-  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
-   \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011 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 <http://www.gnu.org/licenses/>.
-
-Global
-    rhoEqn
-
-Description
-    Solve the continuity for density.
-
-\*---------------------------------------------------------------------------*/
-
-volScalarField Sevap
-(
-    IOobject
-    (
-        "Sevap",
-        runTime.timeName(),
-        mesh,
-        IOobject::NO_READ,
-        IOobject::NO_WRITE
-    ),
-    mesh,
-    dimensionedScalar("zero", dimensionSet(1, -3, -1, 0, 0), 0.0)
-);
-
-forAll(Y, i)
-{
-    if (dieselSpray.isLiquidFuel()[i])
-    {
-        Sevap += dieselSpray.evaporationSource(i);
-    }
-}
-
-{
-    solve
-    (
-        fvm::ddt(rho)
-      + fvc::div(phi)
-      ==
-        Sevap
-    );
-}
-
-// ************************************************************************* //

applications/solvers/combustion/dieselEngineFoam/spraySummary.H

-    label Nparcels = dieselSpray.size();
-    reduce(Nparcels, sumOp<label>());
-
-    Info<< "\nNumber of parcels in system.... | "
-        << Nparcels << endl
-        << "Injected liquid mass........... | "
-        << 1e6*dieselSpray.injectedMass(runTime.value()) << " mg" << endl
-        << "Liquid Mass in system.......... | "
-        << 1e6*dieselSpray.liquidMass() << " mg" << endl
-        << "SMD, Dmax...................... | "
-        << dieselSpray.smd()*1e6 << " mu, "
-        << dieselSpray.maxD()*1e6 << " mu"
-        << endl;
-
-    scalar evapMass =
-        dieselSpray.injectedMass(runTime.value())
-    - dieselSpray.liquidMass();
-
-    scalar gasMass = fvc::domainIntegrate(rho).value();
-
-    if (dieselSpray.twoD())
-    {
-        gasMass *= constant::mathematical::twoPi/dieselSpray.angleOfWedge();
-    }
-
-    scalar addedMass = gasMass - gasMass0;
-
-    Info<< "Added gas mass................. | " << 1e6*addedMass << " mg"
-        << nl << "Evaporation Continuity Error... | "
-        << 1e6*(addedMass - evapMass) << " mg" << endl;

applications/solvers/combustion/dieselFoam/Make/files

-dieselFoam.C
-
-EXE = $(FOAM_APPBIN)/dieselFoam

applications/solvers/combustion/dieselFoam/Make/options

-EXE_INC = \
-    -I../dieselEngineFoam \
-    -I$(LIB_SRC)/finiteVolume/lnInclude \
-    -I$(LIB_SRC)/turbulenceModels/compressible/turbulenceModel \
-    -I$(LIB_SRC)/lagrangian/basic/lnInclude \
-    -I$(LIB_SRC)/meshTools/lnInclude \
-    -I$(LIB_SRC)/lagrangian/dieselSpray/lnInclude \
-    -I$(LIB_SRC)/thermophysicalModels/properties/liquidProperties/lnInclude \
-    -I$(LIB_SRC)/thermophysicalModels/properties/liquidMixtureProperties/lnInclude \
-    -I$(LIB_SRC)/thermophysicalModels/specie/lnInclude \
-    -I$(LIB_SRC)/thermophysicalModels/thermophysicalFunctions/lnInclude \
-    -I$(LIB_SRC)/thermophysicalModels/reactionThermo/lnInclude \
-    -I$(LIB_SRC)/thermophysicalModels/basic/lnInclude \
-    -I$(LIB_SRC)/thermophysicalModels/laminarFlameSpeed/lnInclude \
-    -I$(LIB_SRC)/../applications/solvers/reactionThermo/XiFoam \
-    -I$(LIB_SRC)/thermophysicalModels/chemistryModel/lnInclude \
-    -I$(LIB_SRC)/ODE/lnInclude \
-    -I$(LIB_SRC)/combustionModels/lnInclude
-
-EXE_LIBS = \
-    -lcompressibleTurbulenceModel \
-    -lcompressibleRASModels \
-    -lcompressibleLESModels \
-    -lreactionThermophysicalModels \
-    -llagrangian \
-    -lmeshTools \
-    -ldieselSpray \
-    -lliquidProperties \
-    -lliquidMixtureProperties \
-    -lthermophysicalFunctions \
-    -lspecie \
-    -lbasicThermophysicalModels \
-    -llaminarFlameSpeedModels \
-    -lchemistryModel \
-    -lODE \
-    -ldistributionModels \
-    -lfiniteVolume \
-    -lcombustionModels

applications/solvers/combustion/dieselFoam/dieselFoam.C

-/*---------------------------------------------------------------------------*\
-  =========                 |
-  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
-   \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011 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 <http://www.gnu.org/licenses/>.
-
-Application
-    dieselFoam
-
-Description
-    Solver for diesel spray and combustion.
-
-\*---------------------------------------------------------------------------*/
-
-#include "fvCFD.H"
-#include "psiChemistryCombustionModel.H"
-#include "turbulenceModel.H"
-#include "psiChemistryModel.H"
-#include "chemistrySolver.H"
-#include "spray.H"
-#include "multivariateScheme.H"
-#include "IFstream.H"
-#include "OFstream.H"
-#include "Switch.H"
-#include "mathematicalConstants.H"
-#include "pimpleControl.H"
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-int main(int argc, char *argv[])
-{
-    #include "setRootCase.H"
-    #include "createTime.H"
-    #include "createMesh.H"
-    #include "createFields.H"
-    #include "readGravitationalAcceleration.H"
-    #include "createSpray.H"
-    #include "initContinuityErrs.H"
-    #include "readTimeControls.H"
-    #include "compressibleCourantNo.H"
-    #include "setInitialDeltaT.H"
-
-    pimpleControl pimple(mesh);
-
-    // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-    Info<< "\nStarting time loop\n" << endl;
-
-    while (runTime.run())
-    {
-        #include "compressibleCourantNo.H"
-        #include "setDeltaT.H"
-
-        runTime++;
-        Info<< "Time = " << runTime.timeName() << nl << endl;
-
-        Info<< "Evolving Spray" << endl;
-
-        dieselSpray.evolve();
-
-        Info<< "Solving chemistry" << endl;
-
-        #include "rhoEqn.H"
-
-        // --- Pressure-velocity PIMPLE corrector loop
-        while (pimple.loop())
-        {
-            #include "UEqn.H"
-            #include "YEqn.H"
-            #include "hsEqn.H"
-
-            // --- Pressure corrector loop
-            while (pimple.correct())
-            {
-                #include "pEqn.H"
-            }
-
-            if (pimple.turbCorr())
-            {
-                turbulence->correct();
-            }
-        }
-
-        #include "spraySummary.H"
-
-        rho = thermo.rho();
-
-        runTime.write();
-
-        Info<< "ExecutionTime = " << runTime.elapsedCpuTime() << " s"
-            << "  ClockTime = " << runTime.elapsedClockTime() << " s"
-            << nl << endl;
-    }
-
-    Info<< "End\n" << endl;
-
-    return 0;
-}
-
-
-// ************************************************************************* //

applications/solvers/combustion/dieselFoam/pEqn.H

-rho = thermo.rho();
-
-volScalarField rAU(1.0/UEqn.A());
-U = rAU*UEqn.H();
-
-if (pimple.transonic())
-{
-    surfaceScalarField phid
-    (
-        "phid",
-        fvc::interpolate(psi)
-       *(
-            (fvc::interpolate(U) & mesh.Sf())
-          + fvc::ddtPhiCorr(rAU, rho, U, phi)
-        )
-    );
-
-    while (pimple.correctNonOrthogonal())
-    {
-        fvScalarMatrix pEqn
-        (
-            fvm::ddt(psi, p)
-          + fvm::div(phid, p)
-          - fvm::laplacian(rho*rAU, p)
-         ==
-            Sevap
-        );
-
-        pEqn.solve(mesh.solver(p.select(pimple.finalInnerIter())));
-
-        if (pimple.finalNonOrthogonalIter())
-        {
-            phi == pEqn.flux();
-        }
-    }
-}
-else
-{
-    phi =
-        fvc::interpolate(rho)
-       *(
-            (fvc::interpolate(U) & mesh.Sf())
-          + fvc::ddtPhiCorr(rAU, rho, U, phi)
-        );
-
-    while (pimple.correctNonOrthogonal())
-    {
-        fvScalarMatrix pEqn
-        (
-            fvm::ddt(psi, p)
-          + fvc::div(phi)
-          - fvm::laplacian(rho*rAU, p)
-         ==
-            Sevap
-        );
-
-        pEqn.solve(mesh.solver(p.select(pimple.finalInnerIter())));
-
-        if (pimple.finalNonOrthogonalIter())
-        {
-            phi == pEqn.flux();
-        }
-    }
-}
-
-#include "rhoEqn.H"
-#include "compressibleContinuityErrs.H"
-
-U -= rAU*fvc::grad(p);
-U.correctBoundaryConditions();
-
-DpDt = fvc::DDt(surfaceScalarField("phiU", phi/fvc::interpolate(rho)), p);

applications/solvers/heatTransfer/buoyantBaffleSimpleFoam/Make/files

-buoyantBaffleSimpleFoam.C
-
-EXE = $(FOAM_APPBIN)/buoyantBaffleSimpleFoam

applications/solvers/heatTransfer/buoyantBaffleSimpleFoam/Make/options

-EXE_INC = \
-    -I$(LIB_SRC)/thermophysicalModels/basic/lnInclude \
-    -I$(LIB_SRC)/thermophysicalModels/basicSolidThermo/lnInclude \
-    -I$(LIB_SRC)/thermophysicalModels/specie/lnInclude \
-    -I$(LIB_SRC)/meshTools/lnInclude \
-    -I$(LIB_SRC)/turbulenceModels \
-    -I$(LIB_SRC)/turbulenceModels/compressible/RAS/lnInclude \
-    -I$(LIB_SRC)/finiteVolume/cfdTools \
-    -I$(LIB_SRC)/finiteVolume/lnInclude \
-    -I$(LIB_SRC)/regionModels/regionModel/lnInclude \
-    -I$(LIB_SRC)/regionModels/thermoBaffleModels/lnInclude
-
-EXE_LIBS = \
-    -lmeshTools \
-    -lbasicThermophysicalModels \
-    -lspecie \
-    -lcompressibleTurbulenceModel \
-    -lcompressibleRASModels \
-    -lfiniteVolume \
-    -lmeshTools \
-    -lthermoBaffleModels \
-    -lregionModels

applications/solvers/heatTransfer/buoyantBaffleSimpleFoam/UEqn.H

-    // Solve the Momentum equation
-
-    tmp<fvVectorMatrix> UEqn
-    (
-        fvm::div(phi, U)
-      + turbulence->divDevRhoReff(U)
-    );
-
-    UEqn().relax();
-
-    if (simple.momentumPredictor())
-    {
-        solve
-        (
-            UEqn()
-         ==
-            fvc::reconstruct
-            (
-                (
-                  - ghf*fvc::snGrad(rho)
-                  - fvc::snGrad(p_rgh)
-                )*mesh.magSf()
-            )
-        );
-    }

applications/solvers/heatTransfer/buoyantBaffleSimpleFoam/buoyantBaffleSimpleFoam.C

-/*---------------------------------------------------------------------------*\
-  =========                 |
-  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
-   \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011 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 <http://www.gnu.org/licenses/>.
-
-Application
-    buoyantBaffleSimpleFoam
-
-Description
-    Steady-state solver for buoyant, turbulent flow of compressible fluids
-    using thermal baffles
-
-\*---------------------------------------------------------------------------*/
-
-#include "fvCFD.H"
-#include "basicPsiThermo.H"
-#include "RASModel.H"
-#include "fixedGradientFvPatchFields.H"
-#include "simpleControl.H"
-#include "thermoBaffleModel.H"
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-int main(int argc, char *argv[])
-{
-    #include "setRootCase.H"
-    #include "createTime.H"
-    #include "createMesh.H"
-    #include "readGravitationalAcceleration.H"
-    #include "createFields.H"
-    #include "initContinuityErrs.H"
-
-    simpleControl simple(mesh);
-
-    // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-    Info<< "\nStarting time loop\n" << endl;
-
-    while (simple.loop())
-    {
-        Info<< "Time = " << runTime.timeName() << nl << endl;
-
-        // Pressure-velocity SIMPLE corrector
-        {
-            #include "UEqn.H"
-            #include "hEqn.H"
-            #include "pEqn.H"
-        }
-
-        turbulence->correct();
-
-        runTime.write();
-
-        Info<< "ExecutionTime = " << runTime.elapsedCpuTime() << " s"
-            << "  ClockTime = " << runTime.elapsedClockTime() << " s"
-            << nl << endl;
-    }
-
-    Info<< "End\n" << endl;
-
-    return 0;
-}
-
-
-// ************************************************************************* //

applications/solvers/heatTransfer/buoyantBaffleSimpleFoam/createFields.H

-    Info<< "Reading thermophysical properties\n" << endl;
-
-    autoPtr<basicPsiThermo> pThermo
-    (
-        basicPsiThermo::New(mesh)
-    );
-    basicPsiThermo& thermo = pThermo();
-
-    volScalarField rho
-    (
-        IOobject
-        (
-            "rho",
-            runTime.timeName(),
-            mesh,
-            IOobject::NO_READ,
-            IOobject::NO_WRITE
-        ),
-        thermo.rho()
-    );
-
-    volScalarField& p = thermo.p();
-    volScalarField& h = thermo.h();
-    const volScalarField& psi = thermo.psi();
-
-    Info<< "Reading 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::RASModel> turbulence
-    (
-        compressible::RASModel::New
-        (
-            rho,
-            U,
-            phi,
-            thermo
-        )
-    );
-
-
-    Info<< "Calculating field g.h\n" << endl;
-    volScalarField gh("gh", g & mesh.C());
-    surfaceScalarField ghf("ghf", g & mesh.Cf());
-
-    Info<< "Reading field p_rgh\n" << endl;
-    volScalarField p_rgh
-    (
-        IOobject
-        (
-            "p_rgh",
-            runTime.timeName(),
-            mesh,
-            IOobject::MUST_READ,
-            IOobject::AUTO_WRITE
-        ),
-        mesh
-    );
-
-    // Force p_rgh to be consistent with p
-    p_rgh = p - rho*gh;
-
-
-    label pRefCell = 0;
-    scalar pRefValue = 0.0;
-    setRefCell
-    (
-        p,
-        p_rgh,
-        mesh.solutionDict().subDict("SIMPLE"),
-        pRefCell,
-        pRefValue
-    );
-
-    autoPtr<regionModels::thermoBaffleModels::thermoBaffleModel> baffles
-    (
-        regionModels::thermoBaffleModels::thermoBaffleModel::New(mesh)
-    );
-
-    dimensionedScalar initialMass = fvc::domainIntegrate(rho);
-    dimensionedScalar totalVolume = sum(mesh.V());

applications/solvers/heatTransfer/buoyantBaffleSimpleFoam/hEqn.H

-{
-    fvScalarMatrix hEqn
-    (
-        fvm::div(phi, h)
-      - fvm::Sp(fvc::div(phi), h)
-      - fvm::laplacian(turbulence->alphaEff(), h)
-     ==
-        fvc::div(phi/fvc::interpolate(rho)*fvc::interpolate(p))
-      - p*fvc::div(phi/fvc::interpolate(rho))
-    );
-
-    hEqn.relax();
-    hEqn.solve();
-
-    baffles->evolve();
-    thermo.correct();
-}

applications/solvers/heatTransfer/buoyantBaffleSimpleFoam/pEqn.H

-{
-    rho = thermo.rho();
-    rho.relax();
-
-    volScalarField rAU(1.0/UEqn().A());
-    surfaceScalarField rhorAUf("(rho*(1|A(U)))", fvc::interpolate(rho*rAU));
-
-    U = rAU*UEqn().H();
-    UEqn.clear();
-
-    phi = fvc::interpolate(rho)*(fvc::interpolate(U) & mesh.Sf());
-    bool closedVolume = adjustPhi(phi, U, p_rgh);
-
-    surfaceScalarField buoyancyPhi(rhorAUf*ghf*fvc::snGrad(rho)*mesh.magSf());
-    phi -= buoyancyPhi;
-
-    while (simple.correctNonOrthogonal())
-    {
-        fvScalarMatrix p_rghEqn
-        (
-            fvm::laplacian(rhorAUf, p_rgh) == fvc::div(phi)
-        );
-
-        p_rghEqn.setReference(pRefCell, getRefCellValue(p_rgh, pRefCell));
-        p_rghEqn.solve();
-
-        if (simple.finalNonOrthogonalIter())
-        {
-            // Calculate the conservative fluxes
-            phi -= p_rghEqn.flux();
-
-            // Explicitly relax pressure for momentum corrector
-            p_rgh.relax();
-
-            // Correct the momentum source with the pressure gradient flux
-            // calculated from the relaxed pressure
-            U -= rAU*fvc::reconstruct((buoyancyPhi + p_rghEqn.flux())/rhorAUf);
-            U.correctBoundaryConditions();
-        }
-    }
-
-    #include "continuityErrs.H"
-
-    p = p_rgh + rho*gh;
-
-    // For closed-volume cases adjust the pressure level
-    // to obey overall mass continuity
-    if (closedVolume)
-    {
-        p += (initialMass - fvc::domainIntegrate(psi*p))
-            /fvc::domainIntegrate(psi);
-        p_rgh = p - rho*gh;
-    }
-
-    rho = thermo.rho();
-    rho.relax();
-    Info<< "rho max/min : " << max(rho).value() << " " << min(rho).value()
-        << endl;
-}