void reactingOneDimRPvol2::solveContinuity()
{
if (debug)
{
InfoInFunction << endl;
}
const scalarField mass0 = rho_*regionMesh().V();
fvScalarMatrix rhoEqn
(
fvm::ddt(rho_)
+ fvc::div(phiPyrolysis_)
==
- solidChemistry_->RRg()
);
if (regionMesh().moving())
{
surfaceScalarField phiRhoMesh
(
fvc::interpolate(rho_)*regionMesh().phi()
);
rhoEqn += fvc::div(phiRhoMesh);
}
rhoEqn.solve();
updateMesh(mass0);
}
//---------------------------------------------------------------------------
void fun_pEqn( const fvMeshHolder& mesh,
const TimeHolder& runTime,
const pimpleControlHolder& pimple,
basicPsiThermoHolder& thermo,
volScalarFieldHolder& rho,
volScalarFieldHolder& p,
volScalarFieldHolder& h,
volScalarFieldHolder& psi,
volVectorFieldHolder& U,
surfaceScalarFieldHolder& phi,
compressible::turbulenceModelHolder& turbulence,
fvVectorMatrixHolder& UEqn,
MRFZonesHolder& mrfZones,
volScalarFieldHolder& DpDt,
scalar& cumulativeContErr,
int& corr,
dimensionedScalar& rhoMax,
dimensionedScalar& rhoMin )
{
rho = thermo->rho();
rho = max( rho(), rhoMin );
rho = min( rho(), rhoMax );
rho->relax();
smart_tmp< volScalarField > rAU( 1.0 / UEqn->A() );
U = rAU() * UEqn->H();
if (pimple->nCorr() <= 1)
{
//UEqn->clear();
}
if (pimple->transonic())
{
surfaceScalarField phid( "phid", fvc::interpolate( psi() ) * ( ( fvc::interpolate( U() ) & mesh->Sf() )
+ fvc::ddtPhiCorr( rAU(), rho(), U(), phi() ) ) );
mrfZones->relativeFlux( fvc::interpolate( psi() ), phid);
for (int nonOrth=0; nonOrth <= pimple->nNonOrthCorr(); nonOrth++ )
{
smart_tmp< fvScalarMatrix > pEqn( fvm::ddt( psi(), p() ) + fvm::div( phid, p() ) - fvm::laplacian( rho() * rAU(), p() ) );
pEqn->solve( mesh->solver( p->select( pimple->finalInnerIter( corr, nonOrth ) ) ) );
if ( nonOrth == pimple->nNonOrthCorr() )
{
phi == pEqn->flux();
}
}
}
else
{
phi = fvc::interpolate( rho() ) * ( ( fvc::interpolate( U() ) & mesh->Sf() ) + fvc::ddtPhiCorr( rAU(), rho(), U(), phi() ) );
mrfZones->relativeFlux( fvc::interpolate( rho() ), phi() );
for (int nonOrth=0; nonOrth<=pimple->nNonOrthCorr(); nonOrth++)
{
// Pressure corrector
smart_tmp< fvScalarMatrix > pEqn( fvm::ddt( psi(), p() ) + fvc::div( phi() ) - fvm::laplacian( rho()*rAU(), p() ) );
pEqn->solve( mesh->solver( p->select( pimple->finalInnerIter( corr, nonOrth ) ) ) );
if ( nonOrth == pimple->nNonOrthCorr() )
{
phi += pEqn->flux();
}
}
}
rhoEqn( rho, phi );
compressibleContinuityErrs( thermo, rho, cumulativeContErr );
// Explicitly relax pressure for momentum corrector
p->relax();
// Recalculate density from the relaxed pressure
rho = thermo->rho();
rho = max( rho(), rhoMin );
rho = min( rho(), rhoMax );
rho->relax();
Info<< "rho max/min : " << max( rho() ).value() << " " << min( rho() ).value() << endl;
U -= rAU() * fvc::grad( p() );
U->correctBoundaryConditions();
DpDt = fvc::DDt(surfaceScalarField("phiU", phi() / fvc::interpolate( rho() ) ), p());
}
//---------------------------------------------------------------------------
int main(int argc, char *argv[])
{
argList args = setRootCase( argc, argv );
TimeHolder runTime=createTime( Time::controlDictName, args );
fvMeshHolder mesh = createMesh( runTime );
basicPsiThermoHolder pThermo; volScalarFieldHolder rho; volScalarFieldHolder p;
volScalarFieldHolder h; volScalarFieldHolder psi;
volVectorFieldHolder U; surfaceScalarFieldHolder phi;
compressible::turbulenceModelHolder turbulence;
volScalarFieldHolder DpDt;
result_createFields result = createFields( runTime, mesh, pThermo, rho, p, h, psi, U, phi, turbulence, DpDt );
dimensionedScalar rhoMax = result.m_rhoMax;
dimensionedScalar rhoMin = result.m_rhoMin;
MRFZonesHolder mrfZones;
porousZonesHolder pZones;
Switch pressureImplicitPorosity;
createZones( mesh, U, mrfZones, pZones, pressureImplicitPorosity );
scalar cumulativeContErr = initContinuityErrs();
pimpleControlHolder pimple(mesh);
Info<< "\nStarting time loop\n" << endl;
while (runTime->run())
{
bool adjustTimeStep; scalar maxCo; scalar maxDeltaT;
readTimeControls( runTime, adjustTimeStep, maxCo, maxDeltaT );
scalar coNum, meanCoNum;
compressibleCourantNo( runTime, mesh, phi, rho, coNum, meanCoNum );
setDeltaT( runTime, adjustTimeStep, maxCo, coNum, maxDeltaT );
(*runTime)++;
Info<< "Time = " << runTime->timeName() << nl << endl;
rhoEqn( rho, phi );
// --- Pressure-velocity PIMPLE corrector loop
for (pimple->start(); pimple->loop(); (*pimple)++)
{
if (pimple->nOuterCorr() != 1)
{
p->storePrevIter();
rho->storePrevIter();
}
fvVectorMatrixHolder UEqn = fun_Ueqn( pimple, rho, p, U, phi, turbulence, mrfZones, pZones );
fun_hEqn( pThermo, rho, p, h, phi, turbulence, DpDt );
// --- PISO loop
for (int corr=0; corr<pimple->nCorr(); corr++)
{
fun_pEqn( mesh, runTime, pimple, pThermo, rho, p, h, psi, U, phi, turbulence, UEqn,
mrfZones, DpDt, cumulativeContErr, corr, rhoMax, rhoMin );
}
if (pimple->turbCorr())
{
turbulence->correct();
}
}
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 "createDynamicFvMesh.H"
pimpleControl pimple(mesh);
#include "createFields.H"
#include "createMRF.H"
#include "createTimeControls.H"
#include "createFvOptions.H"
bool checkMeshCourantNo =
readBool(pimple.dict().lookup("checkMeshCourantNo"));
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#include "initContinuityErrs.H"
#include "readCourantType.H"
dimensionedScalar v_zero("v_zero", dimVolume/dimTime, 0.0);
Info<< "\nStarting time loop\n" << endl;
#include "createSurfaceFields.H"
#include "markBadQualityCells.H"
surfaceScalarField meshPhi
(
"volMeshPhi",
phiv_pos * 0.0
);
surfaceScalarField rel_phiv_pos
(
"rel_phiv_pos",
phiv_pos - meshPhi
);
surfaceScalarField rel_phiv_neg
(
"rel_phiv_neg",
phiv_neg - meshPhi
);
#include "initKappaFieldDyM.H"
while (runTime.run())
{
#include "acousticCourantNo.H"
#include "compressibleCourantNo.H"
#include "readTimeControls.H"
#include "setDeltaT.H"
runTime++;
psi.oldTime();
rho.oldTime();
p.oldTime();
U.oldTime();
h.oldTime();
Info<< "Time = " << runTime.timeName() << nl << endl;
// --- Move mesh and update fluxes
{
// Do any mesh changes
mesh.update();
if (mesh.changing())
{
meshPhi = fvc::meshPhi(rho,U)();
if (runTime.timeIndex() > 1)
{
surfaceScalarField amNew = min(min(phiv_pos - meshPhi - cSf_pos, phiv_neg - meshPhi - cSf_neg), v_zero);
phiNeg += kappa*(amNew - am)*p_neg*psi_neg;
phiPos += (1.0 - kappa)*(amNew - am)*p_neg*psi_neg;
}
else
{
phiNeg -= meshPhi * fvc::interpolate(rho);
}
phi = phiPos + phiNeg;
if (checkMeshCourantNo)
{
#include "customMeshCourantNo.H"
}
#include "markBadQualityCells.H"
}
}
// --- Solve density
{
fvScalarMatrix rhoEqn
(
fvm::ddt(rho) + fvc::div(phi)
==
fvOptions(rho)
);
fvOptions.constrain(rhoEqn);
rhoEqn.solve();
fvOptions.correct(rho);
Info<< "rho max/min : " << max(rho).value()
<< " / " << min(rho).value() << endl;
}
// --- Solve momentum
#include "UEqn.H"
// --- Solve energy
#include "hEqn.H"
// --- Solve pressure (PISO)
{
while (pimple.correct())
{
#include "pEqnDyM.H"
}
#include "updateKappa.H"
}
// --- Solve turbulence
turbulence->correct();
Ek = 0.5*magSqr(U);
EkChange = fvc::ddt(rho,Ek) + fvc::div(phiPos,Ek) + fvc::div(phiNeg,Ek);
dpdt = fvc::ddt(p) - fvc::div(meshPhi, p);
runTime.write();
Info<< "ExecutionTime = " << runTime.elapsedCpuTime() << " s"
<< " ClockTime = " << runTime.elapsedClockTime() << " s"
<< nl << endl;
}
Info<< "End\n" << endl;
return 0;
}
