def fun_pEqn(mesh, runTime, simple, U, phi, turbulence, p, UEqn, pRefCell,
pRefValue, cumulativeContErr):
p.ext_boundaryField().updateCoeffs()
rAU = 1.0 / UEqn().A()
U << rAU * UEqn().H()
phi << (ref.fvc.interpolate(U, ref.word("interpolate(HbyA)")) & mesh.Sf())
ref.adjustPhi(phi, U, p)
# Non-orthogonal pressure corrector loop
while simple.correctNonOrthogonal():
pEqn = ref.fvm.laplacian(rAU, p) == ref.fvc.div(phi)
pEqn.setReference(pRefCell, pRefValue)
pEqn.solve()
if simple.finalNonOrthogonalIter():
phi -= pEqn.flux()
pass
pass
cumulativeContErr = ref.ContinuityErrs(phi, runTime, mesh,
cumulativeContErr)
# Explicitly relax pressure for momentum corrector
p.relax()
# Momentum corrector
U -= rAU * ref.fvc.grad(p)
U.correctBoundaryConditions()
return cumulativeContErr
def pEqn(runTime, mesh, pimple, U, rAU, UEqn, phi, p, corr, pRefCell,
pRefValue, cumulativeContErr):
U << rAU * UEqn.H()
if (pimple.nCorr() <= 1):
# UEqn.clear()
pass
phi << (ref.fvc.interpolate(U) & mesh.Sf()) + ref.fvc.ddtPhiCorr(
rAU, U, phi)
ref.adjustPhi(phi, U, p)
# Non-orthogonal pressure corrector loop
for nonOrth in range(pimple.nNonOrthCorr() + 1):
#Pressure corrector
pEqn = ref.fvm.laplacian(rAU, p) == ref.fvc.div(phi)
pEqn.setReference(pRefCell, pRefValue)
pEqn.solve(mesh.solver(p.select(pimple.finalInnerIter(corr, nonOrth))))
if (nonOrth == pimple.nNonOrthCorr()):
phi -= pEqn.flux()
pass
pass
cumulativeContErr = ref.ContinuityErrs(phi, runTime, mesh,
cumulativeContErr)
# Explicitly relax pressure for momentum corrector
p.relax()
U -= rAU * ref.fvc.grad(p)
U.correctBoundaryConditions()
return cumulativeContErr
def pEqn( runTime, mesh, pimple, U, rAU, UEqn, phi, p, pRefCell, pRefValue, cumulativeContErr, sources ):
U << rAU() * ( UEqn == sources( U ) ).H()
if ( pimple.nCorrPISO() <= 1 ):
# UEqn.clear()
pass
phi << ( ref.fvc.interpolate( U ) & mesh.Sf() ) + ref.fvc.ddtPhiCorr( rAU, U, phi )
ref.adjustPhi( phi, U, p )
# Non-orthogonal pressure corrector loop
while pimple.correctNonOrthogonal():
#Pressure corrector
pEqn = ref.fvm.laplacian( rAU, p ) == ref.fvc.div( phi )
pEqn.setReference( pRefCell, pRefValue )
pEqn.solve( mesh.solver( p.select( pimple.finalInnerIter() ) ) )
if pimple.finalNonOrthogonalIter():
phi -= pEqn.flux()
pass
pass
cumulativeContErr = ref.ContinuityErrs( phi, runTime, mesh, cumulativeContErr )
# Explicitly relax pressure for momentum corrector
p.relax()
U -= rAU * ref.fvc.grad( p )
U.correctBoundaryConditions()
sources.correct(U)
return cumulativeContErr
def pEqn( runTime, mesh, pimple, Urel, UrelEqn, phi, p, pRefCell, pRefValue, cumulativeContErr, sources ):
rAUrel = 1.0 / ( UrelEqn == sources( Urel ) ).A()
Urel << rAUrel * UrelEqn.H()
if ( pimple.nCorrPISO() <= 1 ):
# UrelEqn.clear()
pass
phi << ( ref.fvc.interpolate( Urel ) & mesh.Sf() ) + ref.fvc.ddtPhiCorr( rAUrel, Urel, phi )
ref.adjustPhi( phi, Urel, p )
# Non-orthogonal pressure corrector loop
while pimple.correctNonOrthogonal():
#Pressure corrector
pEqn = ref.fvm.laplacian( rAUrel, p ) == ref.fvc.div( phi )
pEqn.setReference( pRefCell, pRefValue )
pEqn.solve( mesh.solver( p.select( pimple.finalInnerIter() ) ) )
if pimple.finalNonOrthogonalIter():
phi -= pEqn.flux()
pass
pass
cumulativeContErr = ref.ContinuityErrs( phi(), runTime, mesh, cumulativeContErr )
# Explicitly relax pressure for momentum corrector
p.relax()
Urel -= rAUrel * ref.fvc.grad( p )
Urel.correctBoundaryConditions()
sources.correct( Urel )
return cumulativeContErr
def fun_pEqn( mesh, runTime, simple, U, phi, turbulence, p, UEqn, pRefCell, pRefValue, cumulativeContErr ):
p.ext_boundaryField().updateCoeffs()
rAU = 1.0 / UEqn().A();
U << rAU * UEqn().H()
phi << ( ref.fvc.interpolate( U, ref.word( "interpolate(HbyA)" ) ) & mesh.Sf() )
ref.adjustPhi(phi, U, p)
# Non-orthogonal pressure corrector loop
while simple.correctNonOrthogonal():
pEqn = ref.fvm.laplacian( rAU, p ) == ref.fvc.div( phi )
pEqn.setReference( pRefCell, pRefValue )
pEqn.solve()
if simple.finalNonOrthogonalIter():
phi -= pEqn.flux()
pass
pass
cumulativeContErr = ref.ContinuityErrs( phi, runTime, mesh, cumulativeContErr )
# Explicitly relax pressure for momentum corrector
p.relax()
# Momentum corrector
U -= rAU * ref.fvc.grad( p )
U.correctBoundaryConditions()
return cumulativeContErr
def main_standalone( argc, argv ):
ref.argList.addBoolOption( ref.word( "writep" ), "write the final pressure field" )
ref.argList.addBoolOption( ref.word( "initialiseUBCs" ), "initialise U boundary conditions" )
args = ref.setRootCase( argc, argv )
runTime = man.createTime( args )
mesh = man.createMesh( runTime )
potentialFlow, nNonOrthCorr = readControls( mesh )
p, U, phi, pRefCell, pRefValue = _createFields( runTime, mesh, potentialFlow,args )
ref.ext_Info() << ref.nl << "Calculating potential flow" << ref.nl
# Since solver contains no time loop it would never execute
# function objects so do it ourselves.
runTime.functionObjects().start()
ref.adjustPhi(phi, U, p)
for nonOrth in range( nNonOrthCorr + 1):
pEqn = ( ref.fvm.laplacian( ref.dimensionedScalar( ref.word( "1" ), ref.dimTime / p.dimensions() * ref.dimensionSet( 0.0, 2.0, -2.0, 0.0, 0.0 ), 1.0 ), p )
== ref.fvc.div( phi ) )
pEqn.setReference( pRefCell, pRefValue )
pEqn.solve()
if nonOrth == nNonOrthCorr:
phi -= pEqn.flux()
pass
pass
ref.ext_Info() << "continuity error = " << ref.fvc.div( phi ).mag().weightedAverage( mesh.V() ).value() << ref.nl
U << ref.fvc.reconstruct( phi )
U.correctBoundaryConditions()
ref.ext_Info() << "Interpolated U error = " << ( ( ( ref.fvc.interpolate( U ) & mesh.Sf() ) - phi ).sqr().sum().sqrt() /mesh.magSf().sum() ).value() << ref.nl
# Force the write
U.write()
phi.write()
if args.optionFound( ref.word( "writep" ) ):
p.write()
pass
runTime.functionObjects().end()
ref.ext_Info() << "ExecutionTime = " << runTime.elapsedCpuTime() << " s" << \
" ClockTime = " << runTime.elapsedClockTime() << " s" << ref.nl << ref.nl
ref.ext_Info() << "End\n" << ref.nl
import os
return os.EX_OK
def fun_pEqn( mesh, simple, p, U, trTU, trAU, UEqn, phi, runTime, pressureImplicitPorosity, \
cumulativeContErr, pRefCell, pRefValue, ):
if pressureImplicitPorosity :
U << ( trTU() & UEqn.H() ) # mixed calculations
pass
else:
U << trAU * UEqn.H()
pass
#UEqn.clear()
phi << ( ref.fvc.interpolate( U ) & mesh.Sf() )
ref.adjustPhi( phi, U, p )
for nonOrth in range( simple.nNonOrthCorr() + 1 ) :
tpEqn = None
if pressureImplicitPorosity :
tpEqn = ( ref.fvm.laplacian( trTU, p ) == ref.fvc.div( phi ) )
pass
else:
tpEqn = ( ref.fvm.laplacian( trAU, p ) == ref.fvc.div( phi ) )
pass
tpEqn.setReference( pRefCell, pRefValue )
# retain the residual from the first iteration
if nonOrth == 0 :
tpEqn.solve()
pass
else:
tpEqn.solve()
pass
if nonOrth == simple.nNonOrthCorr() :
phi-= tpEqn.flux()
pass
pass
cumulativeContErr = ref.ContinuityErrs( phi, runTime, mesh, cumulativeContErr )
# Explicitly relax pressure for momentum corrector
p.relax()
if pressureImplicitPorosity :
U -= ( trTU() & ref.fvc.grad( p ) ) # mixed calcaulations
else:
U -= trAU * ref.fvc.grad( p )
pass
U.correctBoundaryConditions()
return cumulativeContErr
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, 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 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 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 _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 _pEqn( runTime, mesh, UEqn, U, p, p_rgh, gh, ghf, phi, phiAbs, alpha1, rho, g, interface, pimple, pRefCell, pRefValue, cumulativeContErr ):
rAU = 1.0 / UEqn.A()
rAUf = ref.fvc.interpolate( rAU )
U << rAU * UEqn.H()
phiAbs << ( ref.fvc.interpolate( U ) & mesh.Sf() ) + ref.fvc.ddtPhiCorr( rAU, rho, U, phiAbs )
if p_rgh.needReference():
ref.fvc.makeRelative( phiAbs, U )
ref.adjustPhi( phiAbs, U, p_rgh )
ref.fvc.makeAbsolute( phiAbs, U )
pass
phi << phiAbs + ( ref.fvc.interpolate( interface.sigmaK() ) * ref.fvc.snGrad( alpha1 ) - 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() - phiAbs ) / rAUf ) # mixed calculations
U.correctBoundaryConditions()
cumulativeContErr = ref.ContinuityErrs( phi, runTime, mesh, cumulativeContErr )
phiAbs << phi
# 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_pEqn(mesh, runTime, pimple, U, phi, turbulence, p, rAU, UEqn, pRefCell,
pRefValue, cumulativeContErr, ddtPhiCorr):
U << rAU() * UEqn.H()
if pimple.nCorrPISO() <= 1:
#UEqn.clear()
pass
phi << (ref.fvc.interpolate(U) & mesh.Sf())
if ddtPhiCorr:
phi += ref.fvc.ddtPhiCorr(rAU, U, phi)
pass
if p.needReference():
ref.fvc.makeRelative(phi, U)
ref.adjustPhi(phi, U, p)
ref.fvc.makeAbsolute(phi, U)
pass
while pimple.correctNonOrthogonal():
pEqn = ref.fvm.laplacian(rAU, p) == ref.fvc.div(phi)
pEqn.setReference(pRefCell, pRefValue)
pEqn.solve(mesh.solver(p.select(pimple.finalInnerIter())))
if pimple.finalNonOrthogonalIter():
phi -= pEqn.flux()
pass
pass
cumulativeContErr = ref.ContinuityErrs(phi, runTime, mesh,
cumulativeContErr)
# Explicitly relax pressure for momentum corrector
p.relax()
# Make the fluxes relative to the mesh motion
ref.fvc.makeRelative(phi, U)
U -= rAU * ref.fvc.grad(p)
U.correctBoundaryConditions()
return cumulativeContErr
def fun_pEqn( mesh, runTime, pimple, U, phi, turbulence, p, rAU, UEqn, pRefCell, pRefValue, cumulativeContErr, ddtPhiCorr, sources ):
U << rAU() * ( UEqn == sources( U ) ).H()
if pimple.nCorrPISO() <= 1:
#UEqn.clear()
pass
phi << ( ref.fvc.interpolate( U ) & mesh.Sf() )
if ddtPhiCorr:
phi += ref.fvc.ddtPhiCorr(rAU, U, phi)
pass
if p.needReference():
ref.fvc.makeRelative( phi, U )
ref.adjustPhi( phi, U, p )
ref.fvc.makeAbsolute( phi, U )
pass
while pimple.correctNonOrthogonal():
pEqn = ref.fvm.laplacian( rAU, p ) == ref.fvc.div( phi )
pEqn.setReference(pRefCell, pRefValue)
pEqn.solve( mesh.solver( p.select( pimple.finalInnerIter() ) ) )
if pimple.finalNonOrthogonalIter():
phi -= pEqn.flux()
pass
pass
cumulativeContErr = ref.ContinuityErrs( phi, runTime, mesh, cumulativeContErr )
# Explicitly relax pressure for momentum corrector
p.relax()
# Make the fluxes relative to the mesh motion
ref.fvc.makeRelative( phi, U )
U -= rAU * ref.fvc.grad( p )
U.correctBoundaryConditions()
sources.correct(U)
return cumulativeContErr
def fun_correctPhi(runTime, mesh, phi, phiAbs, p, p_rgh, rho, U, cumulativeContErr, pimple, pRefCell, pRefValue):
cumulativeContErr = ref.ContinuityErrs(phi, runTime, mesh, cumulativeContErr)
pcorrTypes = ref.wordList(p_rgh.ext_boundaryField().size(), ref.zeroGradientFvPatchScalarField.typeName)
for i in range(p.ext_boundaryField().size()):
if p_rgh.ext_boundaryField()[i].fixesValue():
pcorrTypes[i] = ref.fixedValueFvPatchScalarField.typeName
pass
pass
pcorr = ref.volScalarField(
ref.IOobject(
ref.word("pcorr"), ref.fileName(runTime.timeName()), mesh, ref.IOobject.NO_READ, ref.IOobject.NO_WRITE
),
mesh,
ref.dimensionedScalar(ref.word("pcorr"), p_rgh.dimensions(), 0.0),
pcorrTypes,
)
rAUf = ref.dimensionedScalar(ref.word("(1|A(U))"), ref.dimTime / rho.dimensions(), 1.0)
ref.adjustPhi(phi, U, pcorr)
ref.fvc.makeAbsolute(phi, U)
while pimple.correctNonOrthogonal():
pcorrEqn = ref.fvm.laplacian(rAUf, pcorr) == ref.fvc.div(phi)
pcorrEqn.setReference(pRefCell, pRefValue)
pcorrEqn.solve()
if pimple.finalNonOrthogonalIter():
phi -= pcorrEqn.flux()
phiAbs << phi
ref.fvc.makeRelative(phi, U)
pass
cumulativeContErr = ref.ContinuityErrs(phi, runTime, mesh, cumulativeContErr)
return cumulativeContErr
def correctPhi(runTime, mesh, phi, p, p_rgh, rho, U, cumulativeContErr, pimple,
pRefCell, pRefValue):
cumulativeContErr = ref.ContinuityErrs(phi, runTime, mesh,
cumulativeContErr)
pcorrTypes = ref.wordList(p_rgh.ext_boundaryField().size(),
ref.zeroGradientFvPatchScalarField.typeName)
for i in range(p.ext_boundaryField().size()):
if p_rgh.ext_boundaryField()[i].fixesValue():
pcorrTypes[i] = ref.fixedValueFvPatchScalarField.typeName
pass
pass
pcorr = ref.volScalarField(
ref.IOobject(ref.word("pcorr"), ref.fileName(runTime.timeName()), mesh,
ref.IOobject.NO_READ, ref.IOobject.NO_WRITE), mesh(),
ref.dimensionedScalar(ref.word("pcorr"), p_rgh.dimensions(), 0.0),
pcorrTypes)
rAUf = ref.dimensionedScalar(ref.word("(1|A(U))"),
ref.dimTime / rho.dimensions(), 1.0)
ref.adjustPhi(phi, U, pcorr)
while pimple.correctNonOrthogonal():
pcorrEqn = ref.fvm.laplacian(rAUf, pcorr) == ref.fvc.div(phi)
pcorrEqn.setReference(pRefCell, pRefValue)
pcorrEqn.solve()
if pimple.finalNonOrthogonalIter():
phi -= pcorrEqn.flux()
pass
cumulativeContErr = ref.ContinuityErrs(phi, runTime, mesh,
cumulativeContErr)
return cumulativeContErr
def fun_pEqn( runTime, mesh, UEqn, U, p, p_rgh, gh, ghf, phi, rho, pimple, corr, 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()
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 )
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 main_standalone(argc, argv):
args = ref.setRootCase(argc, argv)
runTime = man.createTime(args)
mesh = man.createMesh(runTime)
p, U, phi, pa, Ua, phia, alpha, laminarTransport, turbulence, zeroSensitivity, zeroAlpha, \
lambda_, alphaMax, inletCells, pRefCell, pRefValue, paRefCell, paRefValue = createFields( runTime, mesh )
cumulativeContErr = ref.initContinuityErrs()
cumulativeAdjointContErr = initAdjointContinuityErrs()
simple = man.simpleControl(mesh)
ref.ext_Info() << "\nStarting time loop\n" << ref.nl
while simple.loop():
ref.ext_Info() << "Time = " << runTime.timeName() << ref.nl << ref.nl
laminarTransport.lookup(ref.word("lambda")) >> lambda_
alpha += mesh.fieldRelaxationFactor(ref.word("alpha")) * ((
(alpha + lambda_ *
(Ua & U)).ext_max(zeroAlpha)).ext_min(alphaMax) - alpha)
zeroCells(alpha, inletCells)
UEqn = ref.fvm.div(phi, U) + turbulence.divDevReff(U) + ref.fvm.Sp(
alpha, U)
UEqn.relax()
ref.solve(UEqn == -ref.fvc.grad(p))
p.ext_boundaryField().updateCoeffs()
rAU = 1.0 / UEqn.A()
U << rAU * UEqn.H()
phi << (ref.fvc.interpolate(U) & mesh.Sf())
ref.adjustPhi(phi, U, p)
while simple.correctNonOrthogonal():
pEqn = ref.fvm.laplacian(rAU, p) == ref.fvc.div(phi)
pEqn.setReference(pRefCell, pRefValue)
pEqn.solve()
if simple.finalNonOrthogonalIter():
phi -= pEqn.flux()
pass
pass
cumulativeContErr = ref.ContinuityErrs(phi, runTime, mesh,
cumulativeContErr)
# Explicitly relax pressure for momentum corrector
p.relax()
# Momentum corrector
U -= rAU * ref.fvc.grad(p)
U.correctBoundaryConditions()
# Adjoint Pressure-velocity SIMPLE corrector
# Adjoint Momentum predictor
adjointTransposeConvection = (ref.fvc.grad(Ua) & U)
# adjointTransposeConvection = ref.fvc.reconstruct( mesh.magSf() * ( ref.fvc.snGrad( Ua ) & ref.fvc.interpolate( U ) ) )
zeroCells(adjointTransposeConvection, inletCells)
UaEqn = ref.fvm.div(
-phi, Ua) - adjointTransposeConvection + turbulence.divDevReff(
Ua) + ref.fvm.Sp(alpha, Ua)
UaEqn.relax()
ref.solve(UaEqn == -ref.fvc.grad(pa))
pa.ext_boundaryField().updateCoeffs()
rAUa = 1.0 / UaEqn.A()
Ua << rAUa * UaEqn.H()
UaEqn.clear()
phia << (ref.fvc.interpolate(Ua) & mesh.Sf())
ref.adjustPhi(phia, Ua, pa)
# Non-orthogonal pressure corrector loop
while simple.correctNonOrthogonal():
paEqn = ref.fvm.laplacian(rAUa, pa) == ref.fvc.div(phia)
paEqn.setReference(paRefCell, paRefValue)
paEqn.solve()
if simple.finalNonOrthogonalIter():
phia -= paEqn.flux()
pass
pass
cumulativeAdjointContErr = adjointContinuityErrs(
runTime, mesh, phia, cumulativeAdjointContErr)
# Explicitly relax pressure for adjoint momentum corrector
pa.relax()
# Adjoint momentum corrector
Ua -= rAUa * ref.fvc.grad(pa)
Ua.correctBoundaryConditions()
turbulence.correct()
runTime.write()
ref.ext_Info()<< "ExecutionTime = " << runTime.elapsedCpuTime() << " s\n\n" \
<< 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)
p, U, phi, turbulence, pRefCell, pRefValue, laminarTransport = _createFields(runTime, mesh)
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.CourantNo(mesh, phi, runTime)
# Pressure-velocity PISO corrector
# Momentum predictor
# The initial C++ expression does not work properly, because of
# 1. turbulence.divDevRhoReff( U ) - changes values for the U boundaries
# 2. the order of expression arguments computation differs with C++
# UEqn = fvm.ddt( U ) + fvm.div( phi, U ) + turbulence.divDevReff( U )
UEqn = turbulence.divDevReff(U) + (ref.fvm.ddt(U) + ref.fvm.div(phi, U))
UEqn.relax()
if momentumPredictor:
ref.solve(UEqn == -ref.fvc.grad(p))
pass
# --- PISO loop
for corr in range(nCorr):
rUA = 1.0 / UEqn.A()
U << rUA * UEqn.H()
phi << (ref.fvc.interpolate(U) & mesh.Sf()) + ref.fvc.ddtPhiCorr(rUA, U, phi)
ref.adjustPhi(phi, U, p)
# Non-orthogonal pressure corrector loop
for nonOrth in range(nNonOrthCorr + 1):
# Pressure corrector
pEqn = ref.fvm.laplacian(rUA, p) == ref.fvc.div(phi)
pEqn.setReference(pRefCell, pRefValue)
if corr == (nCorr - 1) and nonOrth == nNonOrthCorr:
pEqn.solve(mesh.solver(ref.word("pFinal")))
pass
else:
pEqn.solve()
pass
if nonOrth == nNonOrthCorr:
phi -= pEqn.flux()
pass
pass
cumulativeContErr = ref.ContinuityErrs(phi, runTime, mesh, cumulativeContErr)
U -= rUA * ref.fvc.grad(p)
U.correctBoundaryConditions()
pass
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" << 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 )
transportProperties, nu, Ubar, magUbar, flowDirection = readTransportProperties( runTime, mesh)
p, U, phi, laminarTransport, sgsModel, pRefCell, pRefValue = _createFields( runTime, mesh )
cumulativeContErr = ref.initContinuityErrs()
gradP, gradPFile = createGradP( runTime)
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.CourantNo( mesh, phi, runTime )
sgsModel.correct()
UEqn = ref.fvm.ddt( U ) + ref.fvm.div( phi, U ) + sgsModel.divDevBeff( U ) == flowDirection * gradP
if momentumPredictor:
ref.solve( UEqn == -ref.fvc.grad( p ) )
pass
rAU = 1.0 / UEqn.A()
for corr in range( nCorr ):
U << rAU * UEqn.H()
phi << ( ref.fvc.interpolate( U ) & mesh.Sf() ) + ref.fvc.ddtPhiCorr( rAU, U, phi )
ref.adjustPhi(phi, U, p)
for nonOrth in range( nNonOrthCorr + 1 ):
pEqn = ref.fvm.laplacian( rAU, p ) == ref.fvc.div( phi )
pEqn.setReference( pRefCell, pRefValue )
if corr == nCorr-1 and nonOrth == nNonOrthCorr:
pEqn.solve( mesh.solver( ref.word( str( p.name() ) + "Final" ) ) )
pass
else:
pEqn.solve( mesh.solver( p.name() ) )
pass
if nonOrth == nNonOrthCorr:
phi -= pEqn.flux()
pass
pass
cumulativeContErr = ref.ContinuityErrs( phi, runTime, mesh, cumulativeContErr )
U -= rAU * ref.fvc.grad( p )
U.correctBoundaryConditions()
pass
# Correct driving force for a constant mass flow rate
# Extract the velocity in the flow direction
magUbarStar = ( flowDirection & U ).weightedAverage( mesh.V() )
# Calculate the pressure gradient increment needed to
# adjust the average flow-rate to the correct value
gragPplus = ( magUbar - magUbarStar ) / rAU.weightedAverage( mesh.V() )
U << U() + flowDirection * rAU * gragPplus # mixed caculations
gradP +=gragPplus
ref.ext_Info() << "Uncorrected Ubar = " << magUbarStar.value() << " " << "pressure gradient = " << gradP.value() << ref.nl
runTime.write()
writeGradP( runTime, gradP )
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)
p, U, phi, pa, Ua, phia, alpha, laminarTransport, turbulence, zeroSensitivity, zeroAlpha, lambda_, alphaMax, inletCells, pRefCell, pRefValue, paRefCell, paRefValue = createFields(
runTime, mesh
)
cumulativeContErr = ref.initContinuityErrs()
cumulativeAdjointContErr = initAdjointContinuityErrs()
simple = man.simpleControl(mesh)
ref.ext_Info() << "\nStarting time loop\n" << ref.nl
while simple.loop():
ref.ext_Info() << "Time = " << runTime.timeName() << ref.nl << ref.nl
laminarTransport.lookup(ref.word("lambda")) >> lambda_
alpha += mesh.fieldRelaxationFactor(ref.word("alpha")) * (
((alpha + lambda_ * (Ua & U)).ext_max(zeroAlpha)).ext_min(alphaMax) - alpha
)
zeroCells(alpha, inletCells)
UEqn = ref.fvm.div(phi, U) + turbulence.divDevReff(U) + ref.fvm.Sp(alpha, U)
UEqn.relax()
ref.solve(UEqn == -ref.fvc.grad(p))
p.ext_boundaryField().updateCoeffs()
rAU = 1.0 / UEqn.A()
U << rAU * UEqn.H()
phi << (ref.fvc.interpolate(U) & mesh.Sf())
ref.adjustPhi(phi, U, p)
while simple.correctNonOrthogonal():
pEqn = ref.fvm.laplacian(rAU, p) == ref.fvc.div(phi)
pEqn.setReference(pRefCell, pRefValue)
pEqn.solve()
if simple.finalNonOrthogonalIter():
phi -= pEqn.flux()
pass
pass
cumulativeContErr = ref.ContinuityErrs(phi, runTime, mesh, cumulativeContErr)
# Explicitly relax pressure for momentum corrector
p.relax()
# Momentum corrector
U -= rAU * ref.fvc.grad(p)
U.correctBoundaryConditions()
# Adjoint Pressure-velocity SIMPLE corrector
# Adjoint Momentum predictor
adjointTransposeConvection = ref.fvc.grad(Ua) & U
# adjointTransposeConvection = ref.fvc.reconstruct( mesh.magSf() * ( ref.fvc.snGrad( Ua ) & ref.fvc.interpolate( U ) ) )
zeroCells(adjointTransposeConvection, inletCells)
UaEqn = ref.fvm.div(-phi, Ua) - adjointTransposeConvection + turbulence.divDevReff(Ua) + ref.fvm.Sp(alpha, Ua)
UaEqn.relax()
ref.solve(UaEqn == -ref.fvc.grad(pa))
pa.ext_boundaryField().updateCoeffs()
rAUa = 1.0 / UaEqn.A()
Ua << rAUa * UaEqn.H()
UaEqn.clear()
phia << (ref.fvc.interpolate(Ua) & mesh.Sf())
ref.adjustPhi(phia, Ua, pa)
# Non-orthogonal pressure corrector loop
while simple.correctNonOrthogonal():
paEqn = ref.fvm.laplacian(rAUa, pa) == ref.fvc.div(phia)
paEqn.setReference(paRefCell, paRefValue)
paEqn.solve()
if simple.finalNonOrthogonalIter():
phia -= paEqn.flux()
pass
pass
cumulativeAdjointContErr = adjointContinuityErrs(runTime, mesh, phia, cumulativeAdjointContErr)
# Explicitly relax pressure for adjoint momentum corrector
pa.relax()
# Adjoint momentum corrector
Ua -= rAUa * ref.fvc.grad(pa)
Ua.correctBoundaryConditions()
turbulence.correct()
runTime.write()
ref.ext_Info() << "ExecutionTime = " << runTime.elapsedCpuTime() << " s\n\n" << 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 )
p, U, phi, turbulence, pRefCell, pRefValue, laminarTransport = _createFields( runTime, mesh )
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.CourantNo( mesh, phi, runTime )
# Pressure-velocity PISO corrector
# Momentum predictor
# The initial C++ expression does not work properly, because of
# 1. turbulence.divDevRhoReff( U ) - changes values for the U boundaries
# 2. the order of expression arguments computation differs with C++
# UEqn = fvm.ddt( U ) + fvm.div( phi, U ) + turbulence.divDevReff( U )
UEqn = turbulence.divDevReff( U ) + ( ref.fvm.ddt( U ) + ref.fvm.div( phi, U ) )
UEqn.relax()
if momentumPredictor :
ref.solve( UEqn == -ref.fvc.grad( p ) )
pass
# --- PISO loop
for corr in range( nCorr ) :
rUA = 1.0 / UEqn.A()
U << rUA * UEqn.H()
phi << ( ref.fvc.interpolate(U) & mesh.Sf() ) + ref.fvc.ddtPhiCorr( rUA, U, phi )
ref.adjustPhi( phi, U, p )
# Non-orthogonal pressure corrector loop
for nonOrth in range( nNonOrthCorr + 1 ):
# Pressure corrector
pEqn = ref.fvm.laplacian( rUA, p ) == ref.fvc.div( phi )
pEqn.setReference( pRefCell, pRefValue )
if corr == ( nCorr-1 ) and nonOrth == nNonOrthCorr :
pEqn.solve( mesh.solver( ref.word( "pFinal" ) ) )
pass
else:
pEqn.solve()
pass
if nonOrth == nNonOrthCorr:
phi -= pEqn.flux()
pass
pass
cumulativeContErr = ref.ContinuityErrs( phi, runTime, mesh, cumulativeContErr )
U -= rUA * ref.fvc.grad( p )
U.correctBoundaryConditions()
pass
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" << ref.nl
import os
return os.EX_OK
def main_standalone(argc, argv):
ref.argList.addBoolOption(ref.word("writep"),
"write the final pressure field")
ref.argList.addBoolOption(ref.word("initialiseUBCs"),
"initialise U boundary conditions")
args = ref.setRootCase(argc, argv)
runTime = man.createTime(args)
mesh = man.createMesh(runTime)
potentialFlow, nNonOrthCorr = readControls(mesh)
p, U, phi, pRefCell, pRefValue = _createFields(runTime, mesh,
potentialFlow, args)
ref.ext_Info() << ref.nl << "Calculating potential flow" << ref.nl
# Since solver contains no time loop it would never execute
# function objects so do it ourselves.
runTime.functionObjects().start()
ref.adjustPhi(phi, U, p)
for nonOrth in range(nNonOrthCorr + 1):
pEqn = (ref.fvm.laplacian(
ref.dimensionedScalar(
ref.word("1"), ref.dimTime / p.dimensions() *
ref.dimensionSet(0.0, 2.0, -2.0, 0.0, 0.0), 1.0),
p) == ref.fvc.div(phi))
pEqn.setReference(pRefCell, pRefValue)
pEqn.solve()
if nonOrth == nNonOrthCorr:
phi -= pEqn.flux()
pass
pass
ref.ext_Info() << "continuity error = " << ref.fvc.div(
phi).mag().weightedAverage(mesh.V()).value() << ref.nl
U << ref.fvc.reconstruct(phi)
U.correctBoundaryConditions()
ref.ext_Info() << "Interpolated U error = " << (
((ref.fvc.interpolate(U) & mesh.Sf()) - phi).sqr().sum().sqrt() /
mesh.magSf().sum()).value() << ref.nl
# Force the write
U.write()
phi.write()
if args.optionFound(ref.word("writep")):
p.write()
pass
runTime.functionObjects().end()
ref.ext_Info() << "ExecutionTime = " << runTime.elapsedCpuTime() << " s" << \
" ClockTime = " << runTime.elapsedClockTime() << " s" << ref.nl << ref.nl
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 )
transportProperties, nu, p, U, phi, pRefCell, pRefValue = createFields( runTime, mesh )
cumulativeContErr = ref.initContinuityErrs()
ref.ext_Info() << "\nStarting time loop\n"
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.CourantNo( mesh, phi, runTime )
UEqn = man.fvm.ddt( U ) + man.fvm.div( phi, U ) - man.fvm.laplacian( nu, U )
ref.solve( UEqn == -man.fvc.grad( p ) )
# --- PISO loop
for corr in range( nCorr ) :
rUA = 1.0 / UEqn.A()
U << rUA * UEqn.H()
phi << ( ref.fvc.interpolate( U ) & mesh.Sf() ) + ref.fvc.ddtPhiCorr( rUA, U, phi )
ref.adjustPhi( phi, U, p )
for nonOrth in range( nNonOrthCorr + 1 ) :
pEqn = ( ref.fvm.laplacian( rUA, p ) == ref.fvc.div( phi ) )
pEqn.setReference( pRefCell, pRefValue )
pEqn.solve()
if nonOrth == nNonOrthCorr:
phi -= pEqn.flux()
pass
pass
cumulativeContErr = ref.ContinuityErrs( phi, runTime, mesh, cumulativeContErr )
U -= rUA * ref.fvc.grad( p )
U.correctBoundaryConditions()
pass
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 _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 main_standalone( argc, argv ):
args = ref.setRootCase( argc, argv )
runTime = man.createTime( args )
mesh = man.createMeshNoClear( runTime )
p, U, phi, fluid, pRefCell, pRefValue = _createFields( runTime, mesh )
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.CourantNo( mesh, phi, runTime )
fluid.correct()
UEqn = ref.fvm.ddt( U ) + ref.fvm.div( phi, U ) - ref.fvm.laplacian( fluid.ext_nu(), U ) - ( ref.fvc.grad( U ) & ref.fvc.grad( fluid.ext_nu() ) )
ref.solve( UEqn == -ref.fvc.grad( p ) )
# --- PISO loop
for corr in range( nCorr ):
rAU = 1.0 / UEqn.A()
U << rAU * UEqn.H()
phi << ( ref.fvc.interpolate( U ) & mesh.Sf() ) + ref.fvc.ddtPhiCorr( rAU, U, phi )
ref.adjustPhi(phi, U, p)
for nonOrth in range( nNonOrthCorr + 1):
pEqn = ( ref.fvm.laplacian( rAU, p ) == ref.fvc.div( phi ) )
pEqn.setReference( pRefCell, pRefValue )
pEqn.solve()
if nonOrth == nNonOrthCorr:
phi -= pEqn.flux()
pass
pass
cumulativeContErr = ref.ContinuityErrs( phi, runTime, mesh, cumulativeContErr )
U -= rAU * ref.fvc.grad( p )
U.correctBoundaryConditions()
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 _pEqn( runTime,mesh, UEqn, rho, thermo, psi, U, p, phi, trTU, trAU, mrfZones, \
pRefCell, pRefValue, pressureImplicitPorosity, cumulativeContErr, simple, rhoMin, rhoMax ):
if pressureImplicitPorosity:
U << ( trTU() & UEqn.H() ) # mixed calculations
pass
else:
U << ( trAU() * UEqn.H() ) # mixed calculations
pass
# UEqn.clear()
closedVolume = False
if simple.transonic():
phid = surfaceScalarField( ref.word( "phid" ),
ref.fvc.interpolate( psi ) * ( ref.fvc.interpolate( U ) & mesh.Sf() ) )
mrfZones.relativeFlux( ref.fvc.interpolate( psi ), phid )
while simple.correctNonOrthogonal():
if pressureImplicitPorosity:
tpEqn = ref.fvc.div( phid, p ) - ref.fvm.laplacian( rho * trTU, p )
pass
else:
tpEqn = ref.fvc.div( phid, p ) - ref.fvm.laplacian( rho * trAU, p )
pass
tpEqn.setReference( pRefCell, pRefValue )
tpEqn.solve()
if simple.finalNonOrthogonalIter():
phi == tpEqn.flux()
pass
pass
else:
phi << ( ref.fvc.interpolate( rho * U ) & mesh.Sf() )
mrfZones.relativeFlux( ref.fvc.interpolate( rho ), phi )
closedVolume = ref.adjustPhi( phi, U, p )
while simple.correctNonOrthogonal():
if pressureImplicitPorosity:
tpEqn = ( ref.fvm.laplacian( rho * trTU, p ) == ref.fvc.div( phi ) )
pass
else:
tpEqn = ( ref.fvm.laplacian( rho * trAU, p ) == ref.fvc.div( phi ) )
pass
tpEqn.setReference( pRefCell, pRefValue )
tpEqn.solve()
if simple.finalNonOrthogonalIter():
phi -= tpEqn.flux()
pass
pass
cumulativeContErr = ref.ContinuityErrs( phi, runTime, mesh, cumulativeContErr )
# Explicitly relax pressure for momentum corrector
p.relax()
if pressureImplicitPorosity:
U -= ( trTU() & ref.fvc.grad(p) ) # mixed calculations
pass
else:
U -= trAU() * ref.fvc.grad(p) # mixed calculations
pass
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 )
rho.relax()
ref.ext_Info() << "rho max/min : " << rho.ext_max().value() << " " << rho.ext_min().value() << ref.nl
pass
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
