def fun_pEqn( mesh, runTime, pimple, thermo, rho, p, h, psi, U, phi, mrfZones, turbulence, UEqn, DpDt, cumulativeContErr, corr, rhoMax, rhoMin ):
rho << thermo.rho()
rho << rho().ext_max( rhoMin )
rho << rho().ext_min( rhoMax )
rho.relax()
rAU = 1.0 / UEqn.A()
U << rAU() * UEqn.H()
if pimple.transonic():
phid = ref.surfaceScalarField( ref.word( "phid" ), ref.fvc.interpolate( psi ) * ( ( ref.fvc.interpolate( U ) & mesh.Sf() ) \
+ ref.fvc.ddtPhiCorr( rAU, rho, U, phi ) ) );
mrfZones.relativeFlux( ref.fvc.interpolate( psi ), phid )
for nonOrth in range( pimple.nNonOrthCorr() + 1 ):
pEqn = ref.fvm.ddt( psi, p) + ref.fvm.div( phid, p ) - ref.fvm.laplacian( rho() * rAU, p ) # mixed calculations
pEqn.solve( mesh.solver( p.select( pimple.finalInnerIter( corr, nonOrth ) ) ) )
if nonOrth == pimple.nNonOrthCorr():
phi == pEqn.flux()
pass
pass
pass
else:
phi << ref.fvc.interpolate( rho ) * ( ( ref.fvc.interpolate( U ) & mesh.Sf() ) + ref.fvc.ddtPhiCorr( rAU, rho, U, phi ) )
mrfZones.relativeFlux( ref.fvc.interpolate( rho ), phi )
for nonOrth in range( pimple.nNonOrthCorr() + 1 ):
pEqn = ref.fvm.ddt( psi, p ) + ref.fvc.div( phi ) - ref.fvm.laplacian( rho()*rAU, p ) # mixed calculations
pEqn.solve( mesh.solver( p.select( pimple.finalInnerIter( corr, nonOrth ) ) ) )
if nonOrth == pimple.nNonOrthCorr():
phi += pEqn.flux()
pass
pass
pass
ref.rhoEqn( rho, phi )
cumulativeContErr = ref.compressibleContinuityErrs( rho(), thermo, cumulativeContErr ) # mixed calculations
# Explicitly relax pressure for momentum corrector
p.relax()
# Recalculate density from the relaxed pressure
rho << thermo.rho()
rho << rho().ext_max( rhoMin )
rho << rho().ext_min( rhoMax )
rho.relax()
ref.ext_Info()<< "rho max/min : " << rho.ext_max().value() << " " << rho.ext_min().value() << ref.nl
U -= rAU * ref.fvc.grad( p )
U.correctBoundaryConditions()
DpDt << ref.fvc.DDt( ref.surfaceScalarField( ref.word( "phiU" ), phi() / ref.fvc.interpolate( rho ) ), p ) # mixed calculations
return cumulativeContErr
def fun_pEqn(mesh, runTime, pimple, thermo, rho, p, h, psi, U, phi, turbulence,
gh, ghf, p_rgh, UEqn, DpDt, cumulativeContErr, corr):
rho << thermo.rho()
# Thermodynamic density needs to be updated by psi*d(p) after the
# pressure solution - done in 2 parts. Part 1:
thermo.rho() << thermo.rho() - psi() * p_rgh() # mixed calculations
rAU = 1.0 / UEqn.A()
rhorAUf = ref.surfaceScalarField(ref.word("(rho*(1|A(U)))"),
ref.fvc.interpolate(rho * rAU))
U << rAU * UEqn.H()
phi << ref.fvc.interpolate(rho) * ((ref.fvc.interpolate(U) & mesh.Sf()) +
ref.fvc.ddtPhiCorr(rAU, rho, U, phi))
buoyancyPhi = -rhorAUf * ghf * ref.fvc.snGrad(rho) * mesh.magSf()
phi += buoyancyPhi
p_rghDDtEqn = ref.fvc.ddt(rho) + psi * ref.correction(
ref.fvm.ddt(p_rgh)) + ref.fvc.div(phi)
for nonOrth in range(pimple.nNonOrthCorr() + 1):
p_rghEqn = p_rghDDtEqn - ref.fvm.laplacian(rhorAUf, p_rgh)
p_rghEqn.solve(
mesh.solver(p_rgh.select(pimple.finalInnerIter(corr, nonOrth))))
if nonOrth == pimple.nNonOrthCorr():
# 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 * ref.fvc.reconstruct(
(buoyancyPhi + p_rghEqn.flux()) / rhorAUf)
U.correctBoundaryConditions()
pass
pass
p << p_rgh + rho * gh
# Second part of thermodynamic density update
thermo.rho() << thermo.rho() + psi() * p_rgh # mixed calculations
DpDt << ref.fvc.DDt(
ref.surfaceScalarField(ref.word("phiU"),
phi() / ref.fvc.interpolate(rho)),
p) # mixed calculations
ref.rhoEqn(rho, phi)
cumulativeContErr = ref.compressibleContinuityErrs(
rho(), thermo, cumulativeContErr) #mixed calculations
return cumulativeContErr
def fun_pEqn( mesh, runTime, thermo, rho, p, psi, U, phi, turbulence, UEqn, cumulativeContErr, nNonOrthCorr ):
rho<<thermo.rho()
rAU = 1.0 / UEqn.A()
U<< rAU * UEqn.H()
phid = ref.surfaceScalarField( ref.word( "phid" ),
ref.fvc.interpolate( psi ) *
( ( ref.fvc.interpolate( U ) & mesh.Sf() ) + ref.fvc.ddtPhiCorr( rAU, rho, U, phi ) ) )
for nonOrth in range( nNonOrthCorr + 1 ):
pEqn = ref.fvm.ddt( psi, p ) + ref.fvm.div( phid, p ) - ref.fvm.laplacian( rho * rAU, p )
pEqn.solve()
pass
if nonOrth == nNonOrthCorr:
phi<< pEqn.flux()
pass
ref.rhoEqn( rho, phi )
cumulativeContErr = ref.compressibleContinuityErrs( rho(), thermo, cumulativeContErr ) #it is necessary to force "mixed calculations" implementation
U -= rAU * ref.fvc.grad( p )
U.correctBoundaryConditions()
return cumulativeContErr
def fun_pEqn( mesh, runTime, simple, thermo, rho, p, h, psi, U, phi, turbulence, \
gh, ghf, p_rgh, UEqn, pRefCell, pRefValue, cumulativeContErr, initialMass):
rho << thermo.rho()
rho.relax()
rAU = 1.0 / UEqn.A()
rhorAUf = ref.surfaceScalarField(ref.word("(rho*(1|A(U)))"),
ref.fvc.interpolate(rho() * rAU))
U << rAU * UEqn.H()
phi << ref.fvc.interpolate(rho) * (ref.fvc.interpolate(U()) & mesh.Sf())
closedVolume = ref.adjustPhi(phi, U, p_rgh)
buoyancyPhi = rhorAUf * ghf * ref.fvc.snGrad(rho) * mesh.magSf()
phi -= buoyancyPhi
while simple.correctNonOrthogonal():
p_rghEqn = (ref.fvm.laplacian(rhorAUf, p_rgh) == ref.fvc.div(phi))
p_rghEqn.setReference(pRefCell, ref.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 * ref.fvc.reconstruct(
(buoyancyPhi + p_rghEqn.flux()) / rhorAUf)
U.correctBoundaryConditions()
pass
pass
cumulativeContErr = ref.ContinuityErrs(phi, runTime, mesh,
cumulativeContErr)
p << p_rgh + rho * gh
# For closed-volume cases adjust the pressure level
# to obey overall mass continuity
if closedVolume:
p += (initialMass -
ref.fvc.domainIntegrate(psi * p)) / ref.fvc.domainIntegrate(psi)
p_rgh << p - rho * gh
pass
rho << thermo.rho()
rho.relax()
ref.ext_Info() << "rho max/min : " << rho.ext_max().value(
) << " " << rho.ext_min().value() << ref.nl
return cumulativeContErr
def _UEqn(mesh, alpha1, U, p, p_rgh, ghf, rho, rhoPhi, turbulence, g, twoPhaseProperties, interface, pimple):
muEff = ref.surfaceScalarField(
ref.word("muEff"), twoPhaseProperties.muf() + ref.fvc.interpolate(rho * turbulence.ext_nut())
)
UEqn = (
ref.fvm.ddt(rho, U)
+ ref.fvm.div(rhoPhi, U)
- ref.fvm.laplacian(muEff, U)
- (ref.fvc.grad(U) & ref.fvc.grad(muEff))
)
UEqn.relax()
if pimple.momentumPredictor():
ref.solve(
UEqn
== ref.fvc.reconstruct(
(
ref.fvc.interpolate(interface.sigmaK()) * ref.fvc.snGrad(alpha1)
- ghf * ref.fvc.snGrad(rho)
- ref.fvc.snGrad(p_rgh)
)
* mesh.magSf()
)
)
pass
return UEqn
def fun_pEqn(mesh, runTime, thermo, rho, p, psi, U, phi, turbulence, UEqn,
cumulativeContErr, nNonOrthCorr):
rho << thermo.rho()
rAU = 1.0 / UEqn.A()
U << rAU * UEqn.H()
phid = ref.surfaceScalarField(
ref.word("phid"),
ref.fvc.interpolate(psi) * ((ref.fvc.interpolate(U) & mesh.Sf()) +
ref.fvc.ddtPhiCorr(rAU, rho, U, phi)))
for nonOrth in range(nNonOrthCorr + 1):
pEqn = ref.fvm.ddt(psi, p) + ref.fvm.div(phid, p) - ref.fvm.laplacian(
rho * rAU, p)
pEqn.solve()
pass
if nonOrth == nNonOrthCorr:
phi << pEqn.flux()
pass
ref.rhoEqn(rho, phi)
cumulativeContErr = ref.compressibleContinuityErrs(
rho(), thermo, cumulativeContErr
) #it is necessary to force "mixed calculations" implementation
U -= rAU * ref.fvc.grad(p)
U.correctBoundaryConditions()
return cumulativeContErr
def fun_pEqn( mesh, runTime, simple, thermo, rho, p, h, psi, U, phi, turbulence, \
gh, ghf, p_rgh, UEqn, pRefCell, pRefValue, cumulativeContErr, initialMass):
rho << thermo.rho()
rho.relax()
rAU = 1.0 / UEqn.A()
rhorAUf = ref.surfaceScalarField( ref.word( "(rho*(1|A(U)))" ), ref.fvc.interpolate( rho() * rAU ) )
U << rAU * UEqn.H()
#UEqn.clear()
phi << ref.fvc.interpolate( rho ) * ( ref.fvc.interpolate( U() ) & mesh.Sf() )
closedVolume = ref.adjustPhi( phi, U, p_rgh )
buoyancyPhi = rhorAUf * ghf * ref.fvc.snGrad( rho ) * mesh.magSf()
phi -= buoyancyPhi
for nonOrth in range( simple.nNonOrthCorr() + 1 ):
p_rghEqn = ( ref.fvm.laplacian( rhorAUf, p_rgh ) == ref.fvc.div( phi ) )
p_rghEqn.setReference( pRefCell, ref.getRefCellValue( p_rgh, pRefCell ) )
p_rghEqn.solve()
if nonOrth == simple.nNonOrthCorr():
# 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 * ref.fvc.reconstruct( ( buoyancyPhi + p_rghEqn.flux() ) / rhorAUf )
U.correctBoundaryConditions()
pass
pass
cumulativeContErr = ref.ContinuityErrs( phi, runTime, mesh, cumulativeContErr )
p << p_rgh + rho * gh
# For closed-volume cases adjust the pressure level
# to obey overall mass continuity
if closedVolume:
p += ( initialMass - ref.fvc.domainIntegrate( psi * p ) ) / ref.fvc.domainIntegrate( psi )
p_rgh << p - rho * gh
pass
rho << thermo.rho()
rho.relax()
ref.ext_Info() << "rho max/min : " << rho.ext_max().value() << " " << rho.ext_min().value() << ref.nl
return cumulativeContErr
def fun_pEqn( runTime, mesh, pimple, UEqn, p, p_rgh, phi, U, rho, rho1, rho2, rho10, rho20, gh, ghf, dgdt, pMin, \
psi1, psi2, alpha1, alpha2, interface, corr ):
rAU = 1.0 / UEqn.A()
rAUf = ref.fvc.interpolate(rAU)
p_rghEqnComp = None
if pimple.transonic():
p_rghEqnComp = ref.fvm.ddt(p_rgh) + ref.fvm.div(
phi, p_rgh) - ref.fvm.Sp(ref.fvc.div(phi), p_rgh)
pass
else:
p_rghEqnComp = ref.fvm.ddt(p_rgh) + ref.fvc.div(
phi, p_rgh) - ref.fvc.Sp(ref.fvc.div(phi), p_rgh)
pass
U << rAU * UEqn.H()
phiU = ref.surfaceScalarField(ref.word("phiU"),
(ref.fvc.interpolate(U) & mesh.Sf()) +
ref.fvc.ddtPhiCorr(rAU, rho, U, phi))
phi << (phiU +
(ref.fvc.interpolate(interface.sigmaK()) * ref.fvc.snGrad(alpha1) -
ghf * ref.fvc.snGrad(rho)) * rAUf * mesh.magSf())
for nonOrth in range(pimple.nNonOrthCorr() + 1):
p_rghEqnIncomp = ref.fvc.div(phi) - ref.fvm.laplacian(rAUf, p_rgh)
ref.solve(
(alpha1.ext_max(0.0) * (psi1 / rho1) + alpha2.ext_max(0.0) *
(psi2 / rho2)) * p_rghEqnComp() + p_rghEqnIncomp, ##
mesh.solver(p_rgh.select(pimple.finalInnerIter(corr, nonOrth))))
if nonOrth == pimple.nNonOrthCorr():
dgdt << (alpha2.pos() * (psi2 / rho2) - alpha1.pos() *
(psi1 / rho1)) * (p_rghEqnComp & p_rgh)
phi += p_rghEqnIncomp.flux()
pass
U += rAU * ref.fvc.reconstruct((phi() - phiU) / rAUf) # mixed calculations
U.correctBoundaryConditions()
p << ((p_rgh() + gh * (alpha1() * rho10 + alpha2 * rho20)) /
(1.0 - gh * (alpha1() * psi1 + alpha2 * psi2))).ext_max(pMin) #
rho1 << rho10 + psi1 * p
rho2 << rho20 + psi2 * p
ref.ext_Info() << "max(U) " << U.mag().ext_max().value() << ref.nl
ref.ext_Info() << "min(p_rgh) " << p_rgh.ext_min().value() << ref.nl
pass
def fun_pEqn(mesh, runTime, simple, p, rhok, U, phi, turbulence, gh, ghf,
p_rgh, UEqn, pRefCell, pRefValue, cumulativeContErr):
rAU = ref.volScalarField(ref.word("rAU"), 1.0 / UEqn.A())
rAUf = ref.surfaceScalarField(ref.word("(1|A(U))"),
ref.fvc.interpolate(rAU))
U << rAU * UEqn.H()
phi << (ref.fvc.interpolate(U) & mesh.Sf())
ref.adjustPhi(phi, U, p_rgh)
buoyancyPhi = rAUf * ghf() * ref.fvc.snGrad(rhok) * mesh.magSf()
phi -= buoyancyPhi
for nonOrth in range(simple.nNonOrthCorr() + 1):
p_rghEqn = ref.fvm.laplacian(rAUf, p_rgh) == ref.fvc.div(phi)
p_rghEqn.setReference(pRefCell, ref.getRefCellValue(p_rgh, pRefCell))
p_rghEqn.solve()
if nonOrth == simple.nNonOrthCorr():
# 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 * ref.fvc.reconstruct(
(buoyancyPhi + p_rghEqn.flux()) / rAUf)
U.correctBoundaryConditions()
pass
pass
cumulativeContErr = ref.ContinuityErrs(phi, runTime, mesh,
cumulativeContErr)
p << p_rgh + rhok * gh
if p_rgh.needReference():
p += ref.dimensionedScalar(
ref.word("p"), p.dimensions(),
pRefValue - ref.getRefCellValue(p, pRefCell))
p_rgh << p - rhok * gh
pass
return cumulativeContErr
def fun_pEqn(
mesh, runTime, pimple, thermo, rho, p, h, psi, U, phi, turbulence, gh, ghf, p_rgh, UEqn, dpdt, K, cumulativeContErr
):
rho << thermo.rho()
# Thermodynamic density needs to be updated by psi*d(p) after the
# pressure solution - done in 2 parts. Part 1:
thermo.rho() << thermo.rho() - psi() * p_rgh() # mixed calculations
rAU = 1.0 / UEqn.A()
rhorAUf = ref.surfaceScalarField(ref.word("(rho*(1|A(U)))"), ref.fvc.interpolate(rho * rAU))
U << rAU * UEqn.H()
phi << ref.fvc.interpolate(rho) * ((ref.fvc.interpolate(U) & mesh.Sf()) + ref.fvc.ddtPhiCorr(rAU, rho, U, phi))
buoyancyPhi = -rhorAUf * ghf * ref.fvc.snGrad(rho) * mesh.magSf()
phi += buoyancyPhi
p_rghDDtEqn = ref.fvc.ddt(rho) + psi * ref.correction(ref.fvm.ddt(p_rgh)) + ref.fvc.div(phi)
while pimple.correctNonOrthogonal():
p_rghEqn = p_rghDDtEqn - ref.fvm.laplacian(rhorAUf, p_rgh)
p_rghEqn.solve(mesh.solver(p_rgh.select(pimple.finalInnerIter())))
if pimple.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 * ref.fvc.reconstruct((buoyancyPhi + p_rghEqn.flux()) / rhorAUf)
U.correctBoundaryConditions()
K << 0.5 * U.magSqr()
pass
pass
p << p_rgh + rho * gh
# Second part of thermodynamic density update
thermo.rho() << thermo.rho() + psi() * p_rgh # mixed calculations
dpdt << ref.fvc.ddt(p) # mixed calculations
ref.rhoEqn(rho, phi)
cumulativeContErr = ref.compressibleContinuityErrs(rho(), thermo, cumulativeContErr) # mixed calculations
return cumulativeContErr
def setrDeltaT( runTime, mesh, pimple, phi, psi, U, rho, rDeltaT, maxDeltaT ):
pimpleDict = pimple.dict()
maxCo = pimpleDict.lookupOrDefault( ref.word( "maxCo" ), ref.scalar( 0.8 ) )
rDeltaTSmoothingCoeff = pimpleDict.lookupOrDefault( ref.word( "rDeltaTSmoothingCoeff" ) , ref.scalar( 0.02 ) )
rDeltaTDampingCoeff = pimpleDict.lookupOrDefault( ref.word( "rDeltaTDampingCoeff" ), ref.scalar( 1.0 ) )
maxDeltaT = pimpleDict.lookupOrDefault( ref.word( "maxDeltaT" ), ref.GREAT )
rDeltaT0 = ref.volScalarField( ref.word( "rDeltaT0" ), rDeltaT )
# Set the reciprocal time-step from the local Courant number
tmp = ref.fvc.surfaceSum( phi.mag() )
tmp1= ( tmp.dimensionedInternalField() / ( ( 2 * maxCo ) * mesh.V() * rho.dimensionedInternalField() ) )
print tmp1
rDeltaT.dimensionedInternalField() << tmp1().max( 1.0 / ref.dimensionedScalar( ref.word( "maxDeltaT" ), ref.dimTime, maxDeltaT ) )
if pimple.transonic():
phid = ref.surfaceScalarField( ref.word( "phid" ),
ref.fvc.interpolate( psi ) * ( ref.fvc.interpolate( U ) & mesh.Sf() ) )
rDeltaT.dimensionedInternalField() << rDeltaT.dimensionedInternalField().max( ref.fvc.surfaceSum( phid.mag() ).dimensionedInternalField() /
( ( 2 * maxCo ) * mesh.V() * psi.dimensionedInternalField() ) )
pass
# Update tho boundary values of the reciprocal time-step
rDeltaT.correctBoundaryConditions()
ref.ext_Info() << "Flow time scale min/max = " << ( 1 / rDeltaT.internalField() ).gMin() << ", " << ( 1 / rDeltaT.internalField() ).gMax() << ref.nl
if rDeltaTSmoothingCoeff < 1.0:
ref.fvc.smooth( rDeltaT, rDeltaTSmoothingCoeff )
pass
ref.ext_Info() << "Smoothed flow time scale min/max = " << ( 1 / rDeltaT.internalField() ).gMin() << ", " << ( 1 / rDeltaT.internalField() ).gMax() << ref.nl
# Limit rate of change of time scale
# - reduce as much as required
# - only increase at a fraction of old time scale
if rDeltaTDampingCoeff < 1.0 and runTime.timeIndex() > ( runTime.startTimeIndex() + 1 ) :
rDeltaT = rDeltaT0 * ( rDeltaT / rDeltaT0 ).max( ref.scalar( 1.0 ) - rDeltaTDampingCoeff )
Info<< "Damped flow time scale min/max = " << ( 1 / rDeltaT.internalField() ).gMin() << ", " << ( 1 / rDeltaT.internalField() ).gMax() << ref.nl
pass
pass
def fun_pEqn( mesh, runTime, simple, p, rhok, U, phi, turbulence, gh, ghf, p_rgh, UEqn, pRefCell, pRefValue, cumulativeContErr ):
rAU = ref.volScalarField( ref.word( "rAU" ), 1.0 / UEqn.A() )
rAUf = ref.surfaceScalarField( ref.word( "(1|A(U))" ), ref.fvc.interpolate( rAU ) )
U << rAU * UEqn.H()
phi << ( ref.fvc.interpolate( U ) & mesh.Sf() )
ref.adjustPhi( phi, U, p_rgh );
buoyancyPhi = rAUf * ghf() * ref.fvc.snGrad( rhok ) * mesh.magSf()
phi -= buoyancyPhi
while simple.correctNonOrthogonal():
p_rghEqn = ref.fvm.laplacian( rAUf, p_rgh ) == ref.fvc.div( phi )
p_rghEqn.setReference( pRefCell, ref.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 * ref.fvc.reconstruct( ( buoyancyPhi + p_rghEqn.flux() ) / rAUf )
U.correctBoundaryConditions()
pass
pass
cumulativeContErr = ref.ContinuityErrs( phi, runTime, mesh, cumulativeContErr )
p << p_rgh + rhok * gh
if p_rgh.needReference():
p += ref.dimensionedScalar( ref.word( "p" ), p.dimensions(), pRefValue - ref.getRefCellValue( p, pRefCell ) )
p_rgh << p - rhok * gh
pass
return cumulativeContErr
def _pEqn(runTime, mesh, UEqn, U, p, p_rgh, gh, ghf, phi, alpha1, rho, g,
interface, corr, pimple, pRefCell, pRefValue, cumulativeContErr):
rAU = 1.0 / UEqn.A()
rAUf = ref.fvc.interpolate(rAU)
U << rAU * UEqn.H()
phiU = ref.surfaceScalarField(ref.word("phiU"),
(ref.fvc.interpolate(U) & mesh.Sf()) +
ref.fvc.ddtPhiCorr(rAU, rho, U, phi))
ref.adjustPhi(phiU, U, p)
phi << (phiU +
(ref.fvc.interpolate(interface.sigmaK()) * ref.fvc.snGrad(alpha1) -
ghf * ref.fvc.snGrad(rho)) * rAUf * mesh.magSf())
for nonOrth in range(pimple.nNonOrthCorr() + 1):
p_rghEqn = ref.fvm.laplacian(rAUf, p_rgh) == ref.fvc.div(phi)
p_rghEqn.setReference(pRefCell, pRefValue)
p_rghEqn.solve(
mesh.solver(p_rgh.select(pimple.finalInnerIter(corr, nonOrth))))
if nonOrth == pimple.nNonOrthCorr():
phi -= p_rghEqn.flux()
pass
pass
U += rAU * ref.fvc.reconstruct((phi() - phiU) / rAUf) # mixed calculations
U.correctBoundaryConditions()
cumulativeContErr = ref.ContinuityErrs(phi, runTime, mesh,
cumulativeContErr)
p == p_rgh + rho * gh
if p_rgh.needReference():
p += ref.dimensionedScalar(
ref.word("p"), p.dimensions(),
pRefValue - ref.getRefCellValue(p, pRefCell))
p_rgh << p - rho * gh
pass
return cumulativeContErr
def fun_pEqn( runTime, mesh, pimple, UEqn, p, p_rgh, phi, U, rho, rho1, rho2, rho10, rho20, gh, ghf, dgdt, pMin, \
psi1, psi2, alpha1, alpha2, interface ):
rAU = 1.0/UEqn.A()
rAUf = ref.fvc.interpolate( rAU )
p_rghEqnComp = None
if pimple.transonic():
p_rghEqnComp = ref.fvm.ddt( p_rgh ) + ref.fvm.div( phi, p_rgh ) - ref.fvm.Sp( ref.fvc.div( phi ), p_rgh )
pass
else:
p_rghEqnComp = ref.fvm.ddt( p_rgh ) + ref.fvc.div( phi, p_rgh ) - ref.fvc.Sp( ref.fvc.div( phi ), p_rgh )
pass
U << rAU * UEqn.H()
phiU = ref.surfaceScalarField( ref.word( "phiU" ),
( ref.fvc.interpolate( U ) & mesh.Sf() ) + ref.fvc.ddtPhiCorr( rAU, rho, U, phi ) )
phi << (phiU + ( ref.fvc.interpolate( interface.sigmaK() ) * ref.fvc.snGrad( alpha1 ) - ghf * ref.fvc.snGrad( rho ) ) * rAUf * mesh.magSf() )
while (pimple.correctNonOrthogonal()):
p_rghEqnIncomp = ref.fvc.div( phi ) - ref.fvm.laplacian( rAUf, p_rgh )
ref.solve( ( alpha1.ext_max( 0.0 ) * ( psi1 / rho1 ) + alpha2.ext_max( 0.0 ) * ( psi2 / rho2 ) ) *p_rghEqnComp() + p_rghEqnIncomp, ##
mesh.solver( p_rgh.select( pimple.finalInnerIter() ) ) )
if pimple.finalNonOrthogonalIter():
dgdt << ( alpha2.pos() * ( psi2 / rho2 ) - alpha1.pos() * ( psi1 / rho1 ) ) * ( p_rghEqnComp & p_rgh )
phi += p_rghEqnIncomp.flux()
pass
U += rAU * ref.fvc.reconstruct( ( phi() - phiU ) / rAUf ) # mixed calculations
U.correctBoundaryConditions()
p << ( ( p_rgh() + gh * ( alpha1() * rho10 + alpha2 * rho20 ) ) /( 1.0 - gh * ( alpha1() * psi1 + alpha2 * psi2 ) ) ).ext_max( pMin ) #
rho1 << rho10 + psi1 * p
rho2 << rho20 + psi2 * p
ref.ext_Info() << "max(U) " << U.mag().ext_max().value() << ref.nl
ref.ext_Info() << "min(p_rgh) " << p_rgh.ext_min().value() << ref.nl
pass
def _pEqn( runTime, mesh, UEqn, U, p, p_rgh, gh, ghf, phi, alpha1, rho, g, interface, corr, pimple, pRefCell, pRefValue, cumulativeContErr ):
rAU = 1.0 / UEqn.A()
rAUf = ref.fvc.interpolate( rAU )
U << rAU * UEqn.H()
phiU = ref.surfaceScalarField( ref.word( "phiU" ), ( ref.fvc.interpolate( U ) & mesh.Sf() ) );
if p_rgh.needReference():
ref.fvc.makeRelative( phiU, U )
ref.adjustPhi( phiU, U, p_rgh )
ref.fvc.makeAbsolute( phiU, U )
pass
phi << phiU + ( ref.fvc.interpolate( interface.sigmaK() ) * ref.fvc.snGrad( alpha1 ) - ghf * ref.fvc.snGrad( rho ) ) * rAUf * mesh.magSf()
for nonOrth in range( pimple.nNonOrthCorr() + 1 ):
p_rghEqn = ( ref.fvm.laplacian( rAUf, p_rgh ) == ref.fvc.div( phi ) )
p_rghEqn.setReference( pRefCell, ref.getRefCellValue( p_rgh, pRefCell ) )
p_rghEqn.solve( mesh.solver( p_rgh.select( pimple.finalInnerIter( corr, nonOrth ) ) ) )
if nonOrth == pimple.nNonOrthCorr():
phi -= p_rghEqn.flux()
pass
pass
U += rAU * ref.fvc.reconstruct( ( phi() - phiU ) / rAUf ) # mixed calculations
U.correctBoundaryConditions()
cumulativeContErr = ref.ContinuityErrs( phi, runTime, mesh, cumulativeContErr )
# Make the fluxes relative to the mesh motion
ref.fvc.makeRelative( phi, U )
p == p_rgh + rho * gh
if p_rgh.needReference():
p += ref.dimensionedScalar( ref.word( "p" ),
p.dimensions(),
pRefValue - ref.getRefCellValue( p, pRefCell ) );
p_rgh << p - rho * gh
pass
return cumulativeContErr
def fun_UEqn(mesh, alpha1, U, p, p_rgh, ghf, rho, rhoPhi, turbulence, g,
twoPhaseProperties, interface, pimple):
muEff = ref.surfaceScalarField(
ref.word("muEff"),
twoPhaseProperties.muf() +
ref.fvc.interpolate(rho * turbulence.ext_nut()))
UEqn = ref.fvm.ddt(rho, U) + ref.fvm.div(rhoPhi, U) - ref.fvm.laplacian(
muEff, U) - (ref.fvc.grad(U) & ref.fvc.grad(muEff))
UEqn.relax()
if pimple.momentumPredictor():
ref.solve( UEqn == \
ref.fvc.reconstruct( ( ref.fvc.interpolate( interface.sigmaK() ) * ref.fvc.snGrad( alpha1 ) - ghf * ref.fvc.snGrad( rho ) \
- ref.fvc.snGrad( p_rgh ) ) * mesh.magSf() ) )
pass
return UEqn
def alphaEqn( mesh, phi, alpha1, rhoPhi, rho1, rho2, interface, nAlphaCorr ):
alphaScheme = ref.word( "div(phi,alpha)" )
alpharScheme = ref.word( "div(phirb,alpha)" )
phic = ref.surfaceScalarField( ( phi() / mesh.magSf() ).mag() ) # mixed calculations
phic << ( ( interface.cAlpha() * phic ).ext_min( phic.ext_max() ) )
phir = phic * interface.nHatf()
for aCorr in range( nAlphaCorr ):
phiAlpha = ref.fvc.flux( phi, alpha1, alphaScheme ) + ref.fvc.flux( -ref.fvc.flux( -phir, 1.0 - alpha1, alpharScheme ), alpha1, alpharScheme )
ref.MULES.explicitSolve( alpha1, phi, phiAlpha, 1.0, 0.0 )
rhoPhi << phiAlpha * ( rho1 - rho2 ) + phi * rho2
pass
ref.ext_Info() << "Phase-1 volume fraction = " << alpha1.weightedAverage( mesh.ext_Vsc() ).value() \
<< " Min(alpha1) = " << alpha1.ext_min().value() \
<< " Max(alpha1) = " << alpha1.ext_max().value() << ref.nl
pass
def fun_pEqn( runTime, mesh, UEqn, U, p, p_rgh, gh, ghf, phi, rho, pimple, pRefCell, pRefValue, cumulativeContErr ):
rAU = 1.0/UEqn.A()
rAUf = ref.fvc.interpolate( rAU )
U << rAU * UEqn.H()
phiU = ref.surfaceScalarField( ref.word( "phiU" ),
( ref.fvc.interpolate( U ) & mesh.Sf() ) + ref.fvc.ddtPhiCorr( rAU, rho, U, phi ) )
ref.adjustPhi( phiU, U, p )
phi << phiU - ghf * ref.fvc.snGrad( rho ) * rAUf * mesh.magSf()
while pimple.correctNonOrthogonal():
p_rghEqn = ref.fvm.laplacian( rAUf, p_rgh ) == ref.fvc.div( phi )
p_rghEqn.setReference(pRefCell, ref.getRefCellValue( p_rgh, pRefCell ) )
p_rghEqn.solve( mesh.solver( p_rgh.select( pimple.finalInnerIter() ) ) )
if pimple.finalNonOrthogonalIter():
phi -= p_rghEqn.flux()
pass
pass
U += rAU * ref.fvc.reconstruct( ( phi() - phiU ) / rAUf ) # mixed calculations
U.correctBoundaryConditions()
cumulativeContErr = ref.ContinuityErrs( phi, runTime, mesh, cumulativeContErr )
p == p_rgh + rho * gh
if p_rgh.needReference():
p += ref.dimensionedScalar( ref.word( "p" ),
p.dimensions(),
pRefValue - ref.getRefCellValue( p, pRefCell ) )
p_rgh << p - rho * gh
pass
return cumulativeContErr
def setrDeltaT(runTime, mesh, pimple, phi, psi, U, rho, rDeltaT, maxDeltaT):
pimpleDict = pimple.dict()
maxCo = pimpleDict.lookupOrDefault(ref.word("maxCo"), ref.scalar(0.8))
rDeltaTSmoothingCoeff = pimpleDict.lookupOrDefault(
ref.word("rDeltaTSmoothingCoeff"), ref.scalar(0.02))
rDeltaTDampingCoeff = pimpleDict.lookupOrDefault(
ref.word("rDeltaTDampingCoeff"), ref.scalar(1.0))
maxDeltaT = pimpleDict.lookupOrDefault(ref.word("maxDeltaT"), ref.GREAT)
rDeltaT0 = ref.volScalarField(ref.word("rDeltaT0"), rDeltaT)
# Set the reciprocal time-step from the local Courant number
tmp = ref.fvc.surfaceSum(phi.mag())
tmp1 = (tmp.dimensionedInternalField() /
((2 * maxCo) * mesh.V() * rho.dimensionedInternalField()))
print tmp1
rDeltaT.dimensionedInternalField() << tmp1().max(
1.0 /
ref.dimensionedScalar(ref.word("maxDeltaT"), ref.dimTime, maxDeltaT))
if pimple.transonic():
phid = ref.surfaceScalarField(
ref.word("phid"),
ref.fvc.interpolate(psi) * (ref.fvc.interpolate(U) & mesh.Sf()))
rDeltaT.dimensionedInternalField() << rDeltaT.dimensionedInternalField(
).max(
ref.fvc.surfaceSum(phid.mag()).dimensionedInternalField() /
((2 * maxCo) * mesh.V() * psi.dimensionedInternalField()))
pass
# Update tho boundary values of the reciprocal time-step
rDeltaT.correctBoundaryConditions()
ref.ext_Info() << "Flow time scale min/max = " << (
1 / rDeltaT.internalField()).gMin() << ", " << (
1 / rDeltaT.internalField()).gMax() << ref.nl
if rDeltaTSmoothingCoeff < 1.0:
ref.fvc.smooth(rDeltaT, rDeltaTSmoothingCoeff)
pass
ref.ext_Info() << "Smoothed flow time scale min/max = " << (
1 / rDeltaT.internalField()).gMin() << ", " << (
1 / rDeltaT.internalField()).gMax() << ref.nl
# Limit rate of change of time scale
# - reduce as much as required
# - only increase at a fraction of old time scale
if rDeltaTDampingCoeff < 1.0 and runTime.timeIndex() > (
runTime.startTimeIndex() + 1):
rDeltaT = rDeltaT0 * (
rDeltaT / rDeltaT0).max(ref.scalar(1.0) - rDeltaTDampingCoeff)
Info << "Damped flow time scale min/max = " << (
1 / rDeltaT.internalField()).gMin() << ", " << (
1 / rDeltaT.internalField()).gMax() << ref.nl
pass
pass
def main_standalone(argc, argv):
args = ref.setRootCase(argc, argv)
runTime = man.createTime(args)
mesh = man.createMesh(runTime)
gravitationalProperties, g, rotating, Omega, magg, gHat = readGravitationalAcceleration(runTime, mesh)
h, h0, U, hU, hTotal, phi, F = _createFields(runTime, mesh, Omega, gHat)
pimple = man.pimpleControl(mesh)
ref.ext_Info() << "\nStarting time loop\n" << ref.nl
while runTime.loop():
ref.ext_Info() << "\n Time = " << runTime.timeName() << ref.nl << ref.nl
CourantNo(runTime, mesh, h, phi, magg)
pimple.start()
while pimple.loop():
phiv = ref.surfaceScalarField(ref.word("phiv"), phi() / ref.fvc.interpolate(h)) # mixed calculations
hUEqn = ref.fvm.ddt(hU) + ref.fvm.div(phiv, hU)
hUEqn.relax()
if pimple.momentumPredictor():
if rotating:
ref.solve(hUEqn + (F ^ hU) == -magg * h * ref.fvc.grad(h + h0))
pass
else:
ref.solve(hUEqn == -magg * h * ref.fvc.grad(h + h0))
pass
# Constrain the momentum to be in the geometry if 3D geometry
if mesh.nGeometricD() == 3:
hU -= (gHat & hU) * gHat
hU.correctBoundaryConditions()
pass
for corr in range(pimple.nCorr()):
hf = ref.fvc.interpolate(h)
rUA = 1.0 / hUEqn.A()
ghrUAf = magg * ref.fvc.interpolate(h * rUA)
phih0 = ghrUAf * mesh.magSf() * ref.fvc.snGrad(h0)
if rotating:
hU << rUA * (hUEqn.H() - (F ^ hU))
pass
else:
hU << rUA * hUEqn.H()
pass
phi << (ref.fvc.interpolate(hU) & mesh.Sf()) + ref.fvc.ddtPhiCorr(rUA, h, hU, phi) - phih0
for nonOrth in range(pimple.nNonOrthCorr() + 1):
hEqn = ref.fvm.ddt(h) + ref.fvc.div(phi) - ref.fvm.laplacian(ghrUAf, h)
hEqn.solve(mesh.solver(h.select(pimple.finalInnerIter(corr, nonOrth))))
if nonOrth == pimple.nNonOrthCorr():
phi += hEqn.flux()
pass
hU -= rUA * h * magg * ref.fvc.grad(h + h0)
# Constrain the momentum to be in the geometry if 3D geometry
if mesh.nGeometricD() == 3:
hU -= (gHat & hU) * gHat
pass
hU.correctBoundaryConditions()
pass
pimple.increment()
pass
U == hU / h
hTotal == h + h0
runTime.write()
ref.ext_Info() << "ExecutionTime = " << runTime.elapsedCpuTime() << " s" << " ClockTime = " << runTime.elapsedClockTime() << " s" << ref.nl << ref.nl
pass
ref.ext_Info() << "End\n" << ref.nl
import os
return os.EX_OK
def fun_pEqn( i, mesh, p, rho, turb, thermo, thermoFluid, K, UEqn, U, phi, psi, DpDt, initialMass, p_rgh, gh, ghf, \
nNonOrthCorr, oCorr, nOuterCorr, corr, nCorr, cumulativeContErr ) :
closedVolume = p_rgh.needReference()
compressibility = ref.fvc.domainIntegrate( psi )
compressible = ( compressibility.value() > ref.SMALL )
rho << thermo.rho()
rUA = 1.0 / UEqn.A()
rhorUAf = ref.surfaceScalarField( ref.word( "(rho*(1|A(U)))" ) , ref.fvc.interpolate( rho * rUA ) )
U << rUA * UEqn.H()
phiU = ( ref.fvc.interpolate( rho ) *
( ( ref.fvc.interpolate( U ) & mesh.Sf() ) +
ref.fvc.ddtPhiCorr( rUA, rho, U, phi ) ) )
phi << phiU - rhorUAf * ghf * ref.fvc.snGrad( rho ) * mesh.magSf()
p_rghDDtEqn = ref.fvc.ddt( rho ) + psi * ref.correction( ref.fvm.ddt( p_rgh ) ) + ref.fvc.div( phi )
# Thermodynamic density needs to be updated by psi*d(p) after the
# pressure solution - done in 2 parts. Part 1:
thermo.rho() << thermo.rho() - psi * p_rgh
for nonOrth in range ( nNonOrthCorr + 1 ):
p_rghEqn = p_rghDDtEqn - ref.fvm.laplacian( rhorUAf, p_rgh )
p_rghEqn.solve( mesh.solver( p_rgh.select( ( oCorr == nOuterCorr-1 and corr == nCorr-1 and nonOrth == nNonOrthCorr ) ) ) )
if nonOrth == nNonOrthCorr :
phi += p_rghEqn.flux()
pass
pass
# Second part of thermodynamic density update
thermo.rho() << thermo.rho() + psi * p_rgh
# Correct velocity field
U += rUA * ref.fvc.reconstruct( ( phi() - phiU ) / rhorUAf ) # mixed calculations
U.correctBoundaryConditions()
p << p_rgh + rho * gh
#Update pressure substantive derivative
DpDt << ref.fvc.DDt( ref.surfaceScalarField( ref.word( "phiU" ), phi() / ref.fvc.interpolate( rho ) ), p ) # mixed calculations
# Solve continuity
ref.rhoEqn( rho, phi )
# Update continuity errors
cumulativeContErr = compressibleContinuityErrors( i, mesh, rho, thermo, cumulativeContErr )
# For closed-volume cases adjust the pressure and density levels
# to obey overall mass continuity
if closedVolume and compressible:
p += ( initialMass - ref.fvc.domainIntegrate( thermo.rho() ) ) / compressibility
rho << thermo.rho()
p_rgh << p - rho * gh()
pass
#Update thermal conductivity
K << thermoFluid[ i ].Cp() * turb.alphaEff()
return cumulativeContErr
def main_standalone( argc, argv ):
args = ref.setRootCase( argc, argv )
runTime = man.createTime( args )
mesh = man.createMesh( runTime )
thermo, p, e, T, psi, mu, U, pbf, rhoBoundaryTypes, rho, rhoU, rhoE, pos, \
neg, inviscid, phi, turbulence = _createFields( runTime, mesh )
thermophysicalProperties, Pr = readThermophysicalProperties( runTime, mesh )
fluxScheme = readFluxScheme( mesh )
v_zero = ref.dimensionedScalar( ref.word( "v_zero" ), ref.dimVolume / ref.dimTime, 0.0)
ref.ext_Info() << "\nStarting time loop\n" << ref.nl
while runTime.run() :
# --- upwind interpolation of primitive fields on faces
rho_pos = ref.fvc.interpolate( rho, pos, ref.word( "reconstruct(rho)" ) )
rho_neg = ref.fvc.interpolate( rho, neg, ref.word( "reconstruct(rho)" ) )
rhoU_pos = ref.fvc.interpolate( rhoU, pos, ref.word( "reconstruct(U)" ) )
rhoU_neg = ref.fvc.interpolate( rhoU, neg, ref.word( "reconstruct(U)" ) )
rPsi = 1.0 / psi
rPsi_pos = ref.fvc.interpolate( rPsi, pos, ref.word( "reconstruct(T)" ) )
rPsi_neg = ref.fvc.interpolate( rPsi, neg, ref.word( "reconstruct(T)" ) )
e_pos = ref.fvc.interpolate( e, pos, ref.word( "reconstruct(T)" ) )
e_neg = ref.fvc.interpolate( e, neg, ref.word( "reconstruct(T)" ) )
U_pos = rhoU_pos / rho_pos
U_neg = rhoU_neg / rho_neg
p_pos = rho_pos * rPsi_pos
p_neg = rho_neg * rPsi_neg
phiv_pos = U_pos & mesh.Sf()
phiv_neg = U_neg & mesh.Sf()
c = ( thermo.Cp() / thermo.Cv() * rPsi ).sqrt()
cSf_pos = ref.fvc.interpolate( c, pos, ref.word( "reconstruct(T)" ) ) * mesh.magSf()
cSf_neg = ref.fvc.interpolate( c, neg, ref.word( "reconstruct(T)" ) ) * mesh.magSf()
ap = ( phiv_pos + cSf_pos ).ext_max( phiv_neg + cSf_neg ).ext_max( v_zero )
am = ( phiv_pos - cSf_pos ).ext_min( phiv_neg - cSf_neg ).ext_min( v_zero )
a_pos = ap / ( ap - am )
amaxSf = ref.surfaceScalarField( ref.word( "amaxSf" ), am.mag().ext_max( ap.mag() ) )
aSf = am * a_pos
if str( fluxScheme ) == "Tadmor":
aSf << -0.5 * amaxSf
a_pos << 0.5
pass
a_neg = 1.0 - a_pos
phiv_pos *= a_pos
phiv_neg *= a_neg
aphiv_pos = phiv_pos - aSf
aphiv_neg = phiv_neg + aSf
# Reuse amaxSf for the maximum positive and negative fluxes
# estimated by the central scheme
amaxSf << aphiv_pos.mag().ext_max( aphiv_neg.mag() )
CoNum, meanCoNum = compressibleCourantNo( mesh, amaxSf, runTime )
adjustTimeStep, maxCo, maxDeltaT = ref.readTimeControls( runTime )
runTime = ref.setDeltaT( runTime, adjustTimeStep, maxCo, maxDeltaT, CoNum )
runTime.increment()
ref.ext_Info() << "Time = " << runTime.timeName() << ref.nl << ref.nl
phi << aphiv_pos * rho_pos + aphiv_neg * rho_neg
phiUp = ( aphiv_pos * rhoU_pos + aphiv_neg * rhoU_neg) + ( a_pos * p_pos + a_neg * p_neg ) * mesh.Sf()
phiEp = aphiv_pos * ( rho_pos * ( e_pos + 0.5*U_pos.magSqr() ) + p_pos ) + aphiv_neg * ( rho_neg * ( e_neg + 0.5 * U_neg.magSqr() ) + p_neg )\
+ aSf * p_pos - aSf * p_neg
muEff = turbulence.muEff()
tauMC = ref.volTensorField( ref.word( "tauMC" ) , muEff * ref.fvc.grad(U).T().dev2() )
# --- Solve density
ref.solve( ref.fvm.ddt( rho ) + ref.fvc.div( phi ) )
# --- Solve momentum
ref.solve( ref.fvm.ddt( rhoU ) + ref.fvc.div( phiUp ) )
U.dimensionedInternalField() << rhoU.dimensionedInternalField() / rho.dimensionedInternalField()
U.correctBoundaryConditions()
rhoU.ext_boundaryField() << rho.ext_boundaryField() * U.ext_boundaryField()
rhoBydt = rho / runTime.deltaT()
if not inviscid:
solve( fvm.ddt( rho, U ) - fvc.ddt( rho, U ) - fvm.laplacian( muEff, U ) - fvc.div( tauMC ) )
rhoU << rho * U
pass
# --- Solve energy
sigmaDotU = ( ref.fvc.interpolate( muEff ) * mesh.magSf() * ref.fvc.snGrad( U ) +
( mesh.Sf() & ref.fvc.interpolate( tauMC ) ) ) & ( a_pos * U_pos + a_neg * U_neg )
ref.solve( ref.fvm.ddt( rhoE ) + ref.fvc.div( phiEp ) - ref.fvc.div( sigmaDotU ) )
e << rhoE() / rho() - 0.5 * U.magSqr() # mixed calculations
e.correctBoundaryConditions()
thermo.correct()
rhoE.ext_boundaryField() << rho.ext_boundaryField() * ( e.ext_boundaryField() + 0.5 * U.ext_boundaryField().magSqr() )
if not inviscid :
k = man.volScalarField( ref.word( "k" ) , thermo.Cp() * muEff / Pr )
# The initial C++ expression does not work properly, because of
# 1. the order of expression arguments computation differs with C++
#solve( fvm.ddt( rho, e ) - fvc.ddt( rho, e ) - fvm.laplacian( thermo.alpha(), e ) \
# + fvc.laplacian( thermo.alpha(), e ) - fvc.laplacian( k, T ) )
solve( -fvc.laplacian( k, T ) + ( fvc.laplacian( turbulence.alpha(), e ) \
+ (- fvm.laplacian( turbulence.alphaEff(), e ) + (- fvc.ddt( rho, e ) + fvm.ddt( rho, e ) ) ) ) )
thermo.correct()
rhoE << rho * ( e + 0.5 * U.magSqr() )
pass
p.dimensionedInternalField() << rho.dimensionedInternalField() / psi.dimensionedInternalField()
p.correctBoundaryConditions()
rho.ext_boundaryField() << psi.ext_boundaryField() * p.ext_boundaryField()
turbulence.correct()
runTime.write()
ref.ext_Info() << "ExecutionTime = " << runTime.elapsedCpuTime() << " s" << \
" ClockTime = " << runTime.elapsedClockTime() << " s" << ref.nl << ref.nl
pass
ref.ext_Info() << "End\n"
import os
return os.EX_OK
def fun_pEqn( i, mesh, p, rho, turb, thermo, thermoFluid, K, UEqn, U, phi, psi, DpDt, initialMass, p_rgh, gh, ghf, \
nNonOrthCorr, oCorr, nOuterCorr, corr, nCorr, cumulativeContErr ) :
closedVolume = p_rgh.needReference()
compressibility = ref.fvc.domainIntegrate(psi)
compressible = (compressibility.value() > ref.SMALL)
rho << thermo.rho()
rUA = 1.0 / UEqn.A()
rhorUAf = ref.surfaceScalarField(ref.word("(rho*(1|A(U)))"),
ref.fvc.interpolate(rho * rUA))
U << rUA * UEqn.H()
phiU = (ref.fvc.interpolate(rho) * ((ref.fvc.interpolate(U) & mesh.Sf()) +
ref.fvc.ddtPhiCorr(rUA, rho, U, phi)))
phi << phiU - rhorUAf * ghf * ref.fvc.snGrad(rho) * mesh.magSf()
p_rghDDtEqn = ref.fvc.ddt(rho) + psi * ref.correction(
ref.fvm.ddt(p_rgh)) + ref.fvc.div(phi)
# Thermodynamic density needs to be updated by psi*d(p) after the
# pressure solution - done in 2 parts. Part 1:
thermo.rho() << thermo.rho() - psi * p_rgh
for nonOrth in range(nNonOrthCorr + 1):
p_rghEqn = p_rghDDtEqn - ref.fvm.laplacian(rhorUAf, p_rgh)
p_rghEqn.solve(
mesh.solver(
p_rgh.select((oCorr == nOuterCorr - 1 and corr == nCorr - 1
and nonOrth == nNonOrthCorr))))
if nonOrth == nNonOrthCorr:
phi += p_rghEqn.flux()
pass
pass
# Second part of thermodynamic density update
thermo.rho() << thermo.rho() + psi * p_rgh
# Correct velocity field
U += rUA * ref.fvc.reconstruct(
(phi() - phiU) / rhorUAf) # mixed calculations
U.correctBoundaryConditions()
p << p_rgh + rho * gh
#Update pressure substantive derivative
DpDt << ref.fvc.DDt(
ref.surfaceScalarField(ref.word("phiU"),
phi() / ref.fvc.interpolate(rho)),
p) # mixed calculations
# Solve continuity
ref.rhoEqn(rho, phi)
# Update continuity errors
cumulativeContErr = compressibleContinuityErrors(i, mesh, rho, thermo,
cumulativeContErr)
# For closed-volume cases adjust the pressure and density levels
# to obey overall mass continuity
if closedVolume and compressible:
p += (initialMass -
ref.fvc.domainIntegrate(thermo.rho())) / compressibility
rho << thermo.rho()
p_rgh << p - rho * gh()
pass
#Update thermal conductivity
K << thermoFluid[i].Cp() * turb.alphaEff()
return cumulativeContErr
def main_standalone(argc, argv):
args = ref.setRootCase(argc, argv)
runTime = man.createTime(args)
mesh = man.createDynamicFvMesh(runTime)
cumulativeContErr = ref.initContinuityErrs()
p_rgh, p, alpha1, U, phi, rho1, rho2, rho, rhoPhi, twoPhaseProperties, pRefCell, pRefValue, interface, turbulence, g, gh, ghf = _createFields(
runTime, mesh
)
adjustTimeStep, maxCo, maxDeltaT = ref.readTimeControls(runTime)
pimple = man.pimpleControl(mesh)
phiAbs = ref.surfaceScalarField(ref.word("phiAbs"), phi)
ref.fvc.makeAbsolute(phiAbs, U)
cumulativeContErr = fun_correctPhi(
runTime, mesh, phi, phiAbs, p, p_rgh, rho, U, cumulativeContErr, pimple, pRefCell, pRefValue
)
CoNum, meanCoNum = ref.CourantNo(mesh, phi, runTime)
runTime = ref.setInitialDeltaT(runTime, adjustTimeStep, maxCo, CoNum)
ref.ext_Info() << "\nStarting time loop\n" << ref.nl
while runTime.run():
adjustTimeStep, maxCo, maxDeltaT, correctPhi, checkMeshCourantNo = readControls(runTime, mesh, pimple)
maxAlphaCo, alphaCoNum, meanAlphaCoNum = alphaCourantNo(runTime, mesh, alpha1, phi)
CoNum, meanCoNum = ref.CourantNo(mesh, phi, runTime)
runTime = setDeltaT(runTime, adjustTimeStep, maxCo, CoNum, maxAlphaCo, alphaCoNum, maxDeltaT)
runTime.increment()
ref.ext_Info() << "Time = " << runTime.timeName() << ref.nl << ref.nl
timeBeforeMeshUpdate = runTime.elapsedCpuTime()
fun_Urel(mesh, U)
if mesh.changing():
ref.ext_Info() << "Execution time for mesh.update() = " << runTime.elapsedCpuTime() - timeBeforeMeshUpdate << " s" << ref.nl
gh << (g & mesh.C())
ghf << (g & mesh.Cf())
pass
if mesh.changing() and correctPhi:
cumulativeContErr = fun_correctPhi(
runTime, mesh(), phi, phiAbs, p, p_rgh, rho, U, cumulativeContErr, pimple, pRefCell, pRefValue
)
pass
if mesh.changing() and checkMeshCourantNo:
meshCoNum, meanMeshCoNum = ref.meshCourantNo(runTime, mesh(), phi)
pass
twoPhaseProperties.correct()
alphaEqnSubCycle(runTime, pimple, mesh, phi, alpha1, rho, rhoPhi, rho1, rho2, interface)
# --- Pressure-velocity PIMPLE corrector loop
while pimple.loop():
UEqn = _UEqn(
mesh(), alpha1, U, p, p_rgh, ghf, rho, rhoPhi, turbulence, g, twoPhaseProperties, interface, pimple
)
# --- PISO loop
while pimple.correct():
cumulativeContErr = _pEqn(
runTime,
mesh,
UEqn,
U,
p,
p_rgh,
gh,
ghf,
phi,
phiAbs,
alpha1,
rho,
g,
interface,
pimple,
pRefCell,
pRefValue,
cumulativeContErr,
)
pass
if pimple.turbCorr():
turbulence.correct()
pass
pass
runTime.write()
ref.ext_Info() << "ExecutionTime = " << runTime.elapsedCpuTime() << " s" << " ClockTime = " << runTime.elapsedClockTime() << " s" << ref.nl << ref.nl
pass
ref.ext_Info() << "End\n" << ref.nl
import os
return os.EX_OK
def main_standalone(argc, argv):
args = ref.setRootCase(argc, argv)
runTime = man.createTime(args)
mesh = man.createMesh(runTime)
gravitationalProperties, g, rotating, Omega, magg, gHat = readGravitationalAcceleration(
runTime, mesh)
h, h0, U, hU, hTotal, phi, F = _createFields(runTime, mesh, Omega, gHat)
pimple = man.pimpleControl(mesh)
ref.ext_Info() << "\nStarting time loop\n" << ref.nl
while runTime.loop():
ref.ext_Info() << "\n Time = " << runTime.timeName(
) << ref.nl << ref.nl
CourantNo(runTime, mesh, h, phi, magg)
pimple.start()
while pimple.loop():
phiv = ref.surfaceScalarField(
ref.word("phiv"),
phi() / ref.fvc.interpolate(h)) # mixed calculations
hUEqn = ref.fvm.ddt(hU) + ref.fvm.div(phiv, hU)
hUEqn.relax()
if pimple.momentumPredictor():
if rotating:
ref.solve(hUEqn + (F ^ hU) == -magg * h *
ref.fvc.grad(h + h0))
pass
else:
ref.solve(hUEqn == -magg * h * ref.fvc.grad(h + h0))
pass
# Constrain the momentum to be in the geometry if 3D geometry
if mesh.nGeometricD() == 3:
hU -= (gHat & hU) * gHat
hU.correctBoundaryConditions()
pass
for corr in range(pimple.nCorr()):
hf = ref.fvc.interpolate(h)
rUA = 1.0 / hUEqn.A()
ghrUAf = magg * ref.fvc.interpolate(h * rUA)
phih0 = ghrUAf * mesh.magSf() * ref.fvc.snGrad(h0)
if rotating:
hU << rUA * (hUEqn.H() - (F ^ hU))
pass
else:
hU << rUA * hUEqn.H()
pass
phi << (ref.fvc.interpolate(hU) & mesh.Sf()
) + ref.fvc.ddtPhiCorr(rUA, h, hU, phi) - phih0
for nonOrth in range(pimple.nNonOrthCorr() + 1):
hEqn = ref.fvm.ddt(h) + ref.fvc.div(
phi) - ref.fvm.laplacian(ghrUAf, h)
hEqn.solve(
mesh.solver(
h.select(pimple.finalInnerIter(corr, nonOrth))))
if nonOrth == pimple.nNonOrthCorr():
phi += hEqn.flux()
pass
hU -= rUA * h * magg * ref.fvc.grad(h + h0)
#Constrain the momentum to be in the geometry if 3D geometry
if mesh.nGeometricD() == 3:
hU -= (gHat & hU) * gHat
pass
hU.correctBoundaryConditions()
pass
pimple.increment()
pass
U == hU / h
hTotal == h + h0
runTime.write()
ref.ext_Info() << "ExecutionTime = " << runTime.elapsedCpuTime() << " s" << \
" ClockTime = " << runTime.elapsedClockTime() << " s" << ref.nl << ref.nl
pass
ref.ext_Info() << "End\n" << ref.nl
import os
return os.EX_OK
def main_standalone( argc, argv ):
args = ref.setRootCase( argc, argv )
runTime = man.createTime( args )
mesh = man.createMesh( runTime )
thermodynamicProperties, rho0, p0, psi, rhoO = readThermodynamicProperties( runTime, mesh )
transportProperties, mu = readTransportProperties( runTime, mesh )
p, U, rho, phi = createFields( runTime, mesh, rhoO, psi )
cumulativeContErr = ref.initContinuityErrs()
#// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
ref.ext_Info()<< "\nStarting time loop\n" << ref.nl
while runTime.loop():
ref.ext_Info()<< "Time = " << runTime.timeName() << ref.nl << ref.nl
piso, nCorr, nNonOrthCorr, momentumPredictor, transonic, nOuterCorr = ref.readPISOControls( mesh )
CoNum, meanCoNum = ref.compressibleCourantNo( mesh, phi, rho, runTime )
ref.rhoEqn( rho, phi )
UEqn = man.fvm.ddt( rho, U ) + man.fvm.div( phi, U ) - man.fvm.laplacian( mu, U )
ref.solve( UEqn == -man.fvc.grad( p ) )
# --- PISO loop
for corr in range( nCorr ):
rAU = 1.0 / UEqn.A()
U << rAU * UEqn.H()
phid = ref.surfaceScalarField( ref.word( "phid" ),
psi * ( ( ref.fvc.interpolate( U ) & mesh.Sf() ) + ref.fvc.ddtPhiCorr( rAU, rho(), U(), phi() ) ) )
phi << ( rhoO / psi ) * phid
pEqn = ref.fvm.ddt( psi, p() ) + ref.fvc.div( phi() ) + ref.fvm.div( phid, p() ) - ref.fvm.laplacian( rho() * rAU, p() )
pEqn.solve()
phi += pEqn.flux()
cumulativeContErr = compressibleContinuityErrs( rho, phi,p, rho0, p0, psi, cumulativeContErr )
U -= rAU * ref.fvc.grad( p )
U.correctBoundaryConditions()
pass
rho << rhoO + psi * p
runTime.write()
ref.ext_Info()<< "ExecutionTime = " << runTime.elapsedCpuTime() << " s" \
<< " ClockTime = " << runTime.elapsedClockTime() << " s" \
<< ref.nl << ref.nl
pass
ref.ext_Info()<< "End\n" << ref.nl
import os
return os.EX_OK
def _pEqn( runTime,mesh, UEqn, rho, thermo, psi, U, p, phi, \
pRefCell, pRefValue, cumulativeContErr, simple, rhoMin, rhoMax ):
rho << thermo.rho()
rho << rho.ext_max( rhoMin )
rho << rho.ext_min( rhoMax )
rho.relax()
p0 = ref.volScalarField(p)
AU = ref.volScalarField( UEqn.A() )
AtU = AU - UEqn.H1()
U << UEqn.H() / AU
# UEqn.clear()
closedVolume = False
if simple.transonic():
while simple.correctNonOrthogonal():
phid = ref.surfaceScalarField( ref.word( "phid" ),
ref.fvc.interpolate( psi * U ) & mesh.Sf() )
phic = ref.surfaceScalarField( ref.word( "phic" ),
ref.fvc.interpolate( rho() / AtU - rho() / AU ) * ref.fvc.snGrad( p ) * mesh.magSf() + \
phid * ( ref.fvc.interpolate( p ) - ref.fvc.interpolate( p, ref.word( "UD" ) ) ) ) # mixed calcutions
#refCast<mixedFvPatchScalarField>(p.boundaryField()[1]).refValue()
# = p.boundaryField()[1];
pEqn = ref.fvm.div( phid, p ) + ref.fvc.div( phic ) - ref.fvm.Sp( ref.fvc.div( phid ), p ) + \
ref.fvc.div( phid ) * p - ref.fvm.laplacian( rho() / AtU, p ) # mixed calcutions
# pEqn.relax();
pEqn.setReference( pRefCell, pRefValue )
pEqn.solve()
if simple.finalNonOrthogonalIter():
phi == phic + pEqn.flux()
pass
pass
else:
while simple.correctNonOrthogonal():
phi << ( ref.fvc.interpolate( rho * U ) & mesh.Sf() )
closedVolume = ref.adjustPhi( phi, U, p )
phi += ref.fvc.interpolate( rho / AtU - rho / AU ) * ref.fvc.snGrad( p ) * mesh.magSf()
pEqn = ref.fvc.div( phi ) - ref.fvm.laplacian( rho / AtU, p )
pEqn.setReference( pRefCell, pRefValue )
pEqn.solve()
if simple.finalNonOrthogonalIter():
phi += pEqn.flux()
pass
pass
# The incompressibe for of the continuity error check is appropriate for
# steady-state compressible also.
cumulativeContErr = ref.ContinuityErrs( phi, runTime, mesh, cumulativeContErr )
# Explicitly relax pressure for momentum corrector
p.relax()
U -= ( ref.fvc.grad( p0 ) * ( 1.0 / AU - 1.0 / AtU ) + ref.fvc.grad( p ) / AtU )
# U -= fvc::grad(p)/AU;
U.correctBoundaryConditions()
# For closed-volume cases adjust the pressure and density levels
# to obey overall mass continuity
if closedVolume:
p += ( initialMass - ref.fvc.domainIntegrate( psi * p ) ) / ref.fvc.domainIntegrate( psi )
pass
rho << thermo.rho()
rho << rho.ext_max( rhoMin )
rho << rho.ext_min( rhoMax )
if not simple.transonic():
rho.relax()
pass
ref.ext_Info() << "rho max/min : " << rho.ext_max().value() << " " << rho.ext_min().value() << ref.nl
pass
return cumulativeContErr
def fun_pEqn(
mesh,
runTime,
pimple,
thermo,
rho,
p,
h,
psi,
U,
phi,
turbulence,
UEqn,
rAU,
dpdt,
K,
cumulativeContErr,
rhoMax,
rhoMin,
):
rho << thermo.rho()
rho << rho().ext_max(rhoMin)
rho << rho().ext_min(rhoMax)
rho.relax()
U << rAU() * UEqn.H()
if pimple.transonic():
phid = ref.surfaceScalarField(
ref.word("phid"),
ref.fvc.interpolate(psi) * ((ref.fvc.interpolate(U) & mesh.Sf()) + ref.fvc.ddtPhiCorr(rAU, rho, U, phi)),
)
while pimple.correctNonOrthogonal():
pEqn = ref.fvm.ddt(psi, p) + ref.fvm.div(phid, p) - ref.fvm.laplacian(rho() * rAU, p) # mixed calculations
pEqn.solve(mesh.solver(p.select(pimple.finalInnerIter())))
if pimple.finalNonOrthogonalIter():
phi == pEqn.flux()
pass
pass
pass
else:
phi << ref.fvc.interpolate(rho) * ((ref.fvc.interpolate(U) & mesh.Sf()) + ref.fvc.ddtPhiCorr(rAU, rho, U, phi))
while pimple.correctNonOrthogonal():
pEqn = ref.fvm.ddt(psi, p) + ref.fvc.div(phi) - ref.fvm.laplacian(rho() * rAU, p) # mixed calculations
pEqn.solve(mesh.solver(p.select(pimple.finalInnerIter())))
if pimple.finalNonOrthogonalIter():
phi += pEqn.flux()
pass
pass
pass
ref.rhoEqn(rho, phi)
cumulativeContErr = ref.compressibleContinuityErrs(rho(), thermo, cumulativeContErr) # mixed calculations
# Explicitly relax pressure for momentum corrector
p.relax()
# Recalculate density from the relaxed pressure
rho << thermo.rho()
rho << rho().ext_max(rhoMin)
rho << rho().ext_min(rhoMax)
rho.relax()
ref.ext_Info() << "rho max/min : " << rho.ext_max().value() << " " << rho.ext_min().value() << ref.nl
U -= rAU * ref.fvc.grad(p)
U.correctBoundaryConditions()
K << 0.5 * U.magSqr()
dpdt << ref.fvc.ddt(p)
return cumulativeContErr
def fun_pEqn( runTime, i, mesh, p, rho, turb, thermo, thermoFluid, kappa, UEqn, U, phi, psi, \
initialMass, p_rgh, gh, ghf, nNonOrthCorr, cumulativeContErr, rhoMax, rhoMin, pRefCell, pRefValue ):
rho << thermo.rho()
rho << rho.ext_max( rhoMin[ i ] )
rho << rho.ext_min( rhoMax[ i ] )
rho.relax()
rAU = 1.0 / UEqn.A()
rhorAUf = ref.surfaceScalarField( ref.word( "(rho*(1|A(U)))" ), ref.fvc.interpolate( rho * rAU ) )
U << rAU * UEqn.H()
#UEqn.clear()
phi << ref.fvc.interpolate( rho ) * ( ref.fvc.interpolate( U ) & mesh.Sf() )
closedVolume = ref.adjustPhi( phi, U, p_rgh )
compressibility = ref.fvc.domainIntegrate( psi )
compressible = ( compressibility.value() > ref.SMALL)
buoyancyPhi = rhorAUf * ghf * ref.fvc.snGrad( rho ) * mesh.magSf()
phi -= buoyancyPhi
# Solve pressure
for nonOrth in range( nNonOrthCorr + 1 ):
p_rghEqn = ref.fvm.laplacian( rhorAUf, p_rgh ) == ref.fvc.div( phi )
if compressible:
tmp = ref.getRefCellValue(p_rgh, pRefCell)
pass
else:
tmp = pRefValue
pass
p_rghEqn.setReference( pRefCell, tmp )
p_rghEqn.solve()
if nonOrth == nNonOrthCorr:
# 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 * ref.fvc.reconstruct( ( buoyancyPhi + p_rghEqn.flux() ) / rhorAUf )
U.correctBoundaryConditions()
pass
pass
p << p_rgh + rho * gh
cumulativeContErr = ref.ContinuityErrs( phi, runTime, mesh, cumulativeContErr )
# For closed-volume cases adjust the pressure level
# to obey overall mass continuity
if closedVolume and compressible:
p += ( initialMass - ref.fvc.domainIntegrate( thermo.rho() ) ) / compressibility
p_rgh << p() - rho * gh
pass
rho << thermo.rho();
rho << rho.ext_max( rhoMin[ i ] )
rho << rho.ext_min( rhoMax[ i ] )
rho.relax()
ref.ext_Info() << "Min/max rho:" << rho.ext_min().value() << ' ' << rho.ext_max().value() << ref.nl
# Update thermal conductivity
kappa << thermo.Cp() * turb.alphaEff()
return cumulativeContErr
def main_standalone(argc, argv):
args = ref.setRootCase(argc, argv)
runTime = man.createTime(args)
mesh = man.createMesh(runTime)
thermodynamicProperties, rho0, p0, psi, rhoO = readThermodynamicProperties(
runTime, mesh)
transportProperties, mu = readTransportProperties(runTime, mesh)
p, U, rho, phi = createFields(runTime, mesh, rhoO, psi)
cumulativeContErr = ref.initContinuityErrs()
#// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
ref.ext_Info() << "\nStarting time loop\n" << ref.nl
while runTime.loop():
ref.ext_Info() << "Time = " << runTime.timeName() << ref.nl << ref.nl
piso, nCorr, nNonOrthCorr, momentumPredictor, transonic, nOuterCorr = ref.readPISOControls(
mesh)
CoNum, meanCoNum = ref.compressibleCourantNo(mesh, phi, rho, runTime)
ref.rhoEqn(rho, phi)
UEqn = man.fvm.ddt(rho, U) + man.fvm.div(phi, U) - man.fvm.laplacian(
mu, U)
ref.solve(UEqn == -man.fvc.grad(p))
# --- PISO loop
for corr in range(nCorr):
rAU = 1.0 / UEqn.A()
U << rAU * UEqn.H()
phid = ref.surfaceScalarField(
ref.word("phid"),
psi * ((ref.fvc.interpolate(U) & mesh.Sf()) +
ref.fvc.ddtPhiCorr(rAU, rho(), U(), phi())))
phi << (rhoO / psi) * phid
pEqn = ref.fvm.ddt(psi, p()) + ref.fvc.div(phi()) + ref.fvm.div(
phid, p()) - ref.fvm.laplacian(rho() * rAU, p())
pEqn.solve()
phi += pEqn.flux()
cumulativeContErr = compressibleContinuityErrs(
rho, phi, p, rho0, p0, psi, cumulativeContErr)
U -= rAU * ref.fvc.grad(p)
U.correctBoundaryConditions()
pass
rho << rhoO + psi * p
runTime.write()
ref.ext_Info()<< "ExecutionTime = " << runTime.elapsedCpuTime() << " s" \
<< " ClockTime = " << runTime.elapsedClockTime() << " s" \
<< ref.nl << ref.nl
pass
ref.ext_Info() << "End\n" << ref.nl
import os
return os.EX_OK
