int main(int argc, char *argv[])
{
# include "setRootCase.H"
# include "createTime.H"
# include "createMesh.H"
# include "readThermodynamicProperties.H"
# include "createFields.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
Info<< "\nStarting time loop\n" << endl;
while (runTime.loop())
{
Info<< "Time = " << runTime.value() << nl << endl;
# include "readPISOControls.H"
scalar HbyAblend = readScalar(piso.lookup("HbyAblend"));
# include "readTimeControls.H"
scalar CoNum = max
(
mesh.surfaceInterpolation::deltaCoeffs()
*mag(phiv)/mesh.magSf()
).value()*runTime.deltaT().value();
Info<< "Max Courant Number = " << CoNum << endl;
# include "setDeltaT.H"
for (int outerCorr = 0; outerCorr < nOuterCorr; outerCorr++)
{
magRhoU = mag(rhoU);
H = (rhoE + p)/rho;
fv::multivariateGaussConvectionScheme<scalar> mvConvection
(
mesh,
fields,
phiv,
mesh.schemesDict().divScheme("div(phiv,rhoUH)")
);
solve
(
fvm::ddt(rho)
+ mvConvection.fvmDiv(phiv, rho)
);
surfaceScalarField rhoUWeights =
mvConvection.interpolationScheme()()(magRhoU)()
.weights(magRhoU);
weighted<vector> rhoUScheme(rhoUWeights);
fvVectorMatrix rhoUEqn
(
fvm::ddt(rhoU)
+ fv::gaussConvectionScheme<vector>(mesh, phiv, rhoUScheme)
.fvmDiv(phiv, rhoU)
);
solve(rhoUEqn == -fvc::grad(p));
solve
(
fvm::ddt(rhoE)
+ mvConvection.fvmDiv(phiv, rhoE)
==
- mvConvection.fvcDiv(phiv, p)
);
T = (rhoE - 0.5*rho*magSqr(rhoU/rho))/Cv/rho;
psi = 1.0/(R*T);
p = rho/psi;
for (int corr = 0; corr < nCorr; corr++)
{
volScalarField rrhoUA = 1.0/rhoUEqn.A();
surfaceScalarField rrhoUAf("rrhoUAf", fvc::interpolate(rrhoUA));
volVectorField HbyA = rrhoUA*rhoUEqn.H();
surfaceScalarField HbyAWeights =
HbyAblend*mesh.weights()
+ (1.0 - HbyAblend)*
LimitedScheme
<vector, MUSCLLimiter<NVDTVD>, limitFuncs::magSqr>
(mesh, phi, IStringStream("HbyA")()).weights(HbyA);
phi =
(
surfaceInterpolationScheme<vector>::interpolate
(HbyA, HbyAWeights) & mesh.Sf()
)
+ HbyAblend*fvc::ddtPhiCorr(rrhoUA, rho, rhoU, phi);
p.boundaryField().updateCoeffs();
surfaceScalarField phiGradp =
rrhoUAf*mesh.magSf()*fvc::snGrad(p);
phi -= phiGradp;
# include "resetPhiPatches.H"
surfaceScalarField rhof =
mvConvection.interpolationScheme()()(rho)()
.interpolate(rho);
phiv = phi/rhof;
fvScalarMatrix pEqn
(
fvm::ddt(psi, p)
+ mvConvection.fvcDiv(phiv, rho)
+ fvc::div(phiGradp)
- fvm::laplacian(rrhoUAf, p)
);
pEqn.solve();
phi += phiGradp + pEqn.flux();
rho = psi*p;
rhof =
mvConvection.interpolationScheme()()(rho)()
.interpolate(rho);
phiv = phi/rhof;
rhoU = HbyA - rrhoUA*fvc::grad(p);
rhoU.correctBoundaryConditions();
}
}
U = rhoU/rho;
runTime.write();
Info<< "ExecutionTime = " << runTime.elapsedCpuTime() << " s"
<< " ClockTime = " << runTime.elapsedClockTime() << " s"
<< nl << endl;
}
Info<< "End\n" << endl;
return 0;
}
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];
}
