//---------------------------------------------------------------------------
void fun_TEqn( const surfaceScalarFieldHolder& phi,
incompressible::RASModelHolder& turbulence,
volScalarFieldHolder& kappat,
const volScalarFieldHolder& T,
volScalarFieldHolder& rhok,
const dimensionedScalar& beta,
const dimensionedScalar& TRef,
const dimensionedScalar& Prt,
const dimensionedScalar Pr )
{
kappat = turbulence->nut() / Prt;
kappat->correctBoundaryConditions();
volScalarField kappaEff("kappaEff", turbulence->nu()/Pr + kappat() );
smart_tmp< fvScalarMatrix > TEqn( fvm::div( phi(), T() ) - fvm::Sp(fvc::div( phi() ), T() ) - fvm::laplacian( kappaEff, T() ) );
TEqn->relax();
TEqn->solve();
rhok = 1.0 - beta * ( T() - TRef );
}
int main(int argc, char *argv[])
{
#include "setRootCase.H"
#include "createTime.H"
#include "createMesh.H"
#include "createFields.H"
#include "createFvOptions.H"
#include "initContinuityErrs.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
Info<< "\nStarting time loop\n" << endl;
while (runTime.loop())
{
Info<< "Time = " << runTime.timeName() << nl << endl;
#include "readPISOControls.H"
#include "CourantNo.H"
// Pressure-velocity PISO corrector
{
// Momentum predictor
fvVectorMatrix UEqn
(
fvm::ddt(U)
+ fvm::div(phi, U)
+ turbulence->divDevReff(U)
);
UEqn.relax();
if (momentumPredictor)
{
solve(UEqn == -fvc::grad(p));
}
// --- PISO loop
for (int corr=0; corr<nCorr; corr++)
{
volScalarField rAU(1.0/UEqn.A());
volVectorField HbyA("HbyA", U);
HbyA = rAU*UEqn.H();
surfaceScalarField phiHbyA
(
"phiHbyA",
(fvc::interpolate(HbyA) & mesh.Sf())
+ fvc::interpolate(rAU)*fvc::ddtCorr(U, phi)
);
adjustPhi(phiHbyA, U, p);
// Non-orthogonal pressure corrector loop
for (int nonOrth=0; nonOrth<=nNonOrthCorr; nonOrth++)
{
// Pressure corrector
fvScalarMatrix pEqn
(
fvm::laplacian(rAU, p) == fvc::div(phiHbyA)
);
pEqn.setReference(pRefCell, pRefValue);
if
(
corr == nCorr-1
&& nonOrth == nNonOrthCorr
)
{
pEqn.solve(mesh.solver("pFinal"));
}
else
{
pEqn.solve();
}
if (nonOrth == nNonOrthCorr)
{
phi = phiHbyA - pEqn.flux();
}
}
#include "continuityErrs.H"
U = HbyA - rAU*fvc::grad(p);
U.correctBoundaryConditions();
}
}
turbulence->correct();
/*tmp<fvScalarMatrix> sEqn
(
fvm::ddt(s)
+ fvm::div(phi, s)
- fvm::laplacian(Ds, s)
);
sources.constrain(sEqn());
solve(sEqn() == sources(s));*/
tmp<fv::convectionScheme<scalar> > mvConvection
(
fv::convectionScheme<scalar>::New
(
mesh,
fields,
phi,
mesh.divScheme("div(phi,si_h)")
)
);
volScalarField kappaEff
(
"kappaEff",
turbulence->nu()/Pr + turbulence->nut()/Prt
);
forAll(s, i)
{
volScalarField& si = s[i];
tmp<fvScalarMatrix> siEqn
(
fvm::ddt(si)
+ mvConvection->fvmDiv(phi, si)
- fvm::laplacian(kappaEff, si)
== fvOptions(si)
);
fvOptions.constrain(siEqn());
solve(siEqn(),mesh.solver("si"));
fvOptions.correct(si);
}
//create scalar Fields u*s for averaging
forAll(us, i)
{
us[i]=U*s[i];
}
