def main_standalone( argc, argv ):
args = ref.setRootCase( argc, argv )
runTime = man.createTime( args )
mesh = man.createMesh( runTime )
pimple = man.pimpleControl(mesh)
pThermo, p, h, psi, rho, U, phi, rhoMax, rhoMin, turbulence, dpdt, K = createFields( runTime, mesh, pimple )
mrfZones, pZones, pressureImplicitPorosity = createZones( mesh, U )
cumulativeContErr = ref.initContinuityErrs()
ref.ext_Info()<< "\nStarting time loop\n" << ref.nl;
while runTime.run():
adjustTimeStep, maxCo, maxDeltaT = ref.readTimeControls( runTime )
CoNum, meanCoNum = ref.compressibleCourantNo( mesh, phi, rho, runTime )
runTime = ref.setDeltaT( runTime, adjustTimeStep, maxCo, maxDeltaT, CoNum )
runTime.increment()
ref.ext_Info()<< "Time = " << runTime.timeName() << ref.nl << ref.nl;
ref.rhoEqn( rho, phi )
# --- Pressure-velocity PIMPLE corrector loop
while pimple.loop():
UEqn = fun_Ueqn( pimple, rho, p, U, phi, turbulence, mrfZones, pZones )
fun_hEqn(pThermo, rho, p, h, phi, turbulence, dpdt, K )
# --- PISO loop
while (pimple.correct()):
cumulativeContErr = fun_pEqn( mesh, runTime, pimple, pThermo, rho, p, h, psi, U, phi, mrfZones,
turbulence, UEqn, dpdt, K, cumulativeContErr, rhoMax, rhoMin )
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 )
p, U, phi, turbulence, pRefCell, pRefValue, laminarTransport = _createFields( runTime, mesh )
cumulativeContErr = ref.initContinuityErrs()
pimple = man.pimpleControl( mesh )
ref.ext_Info() << "\nStarting time loop\n" <<ref.nl
while runTime.run() :
adjustTimeStep, maxCo, maxDeltaT = ref.readTimeControls( runTime )
CoNum, meanCoNum = ref.CourantNo( mesh, phi, runTime )
runTime = ref.setDeltaT( runTime, adjustTimeStep, maxCo, maxDeltaT, CoNum )
runTime.increment()
ref.ext_Info() << "Time = " << runTime.timeName() << ref.nl << ref.nl
# --- Pressure-velocity PIMPLE corrector loop
pimple.start()
while pimple.loop():
if pimple.nOuterCorr() != 1 :
p.storePrevIter()
pass
UEqn, rAU = Ueqn( mesh, pimple, phi, U, p, turbulence )
# --- PISO loop
for corr in range( pimple.nCorr() ):
cumulativeContErr = pEqn( runTime, mesh, pimple, U, rAU, UEqn, phi, p, corr, pRefCell, pRefValue, cumulativeContErr )
pass
if pimple.turbCorr():
turbulence.correct()
pass
pimple.increment()
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)
p, U, phi, turbulence, pRefCell, pRefValue, laminarTransport, sources = _createFields(
runTime, mesh)
cumulativeContErr = ref.initContinuityErrs()
pimple = man.pimpleControl(mesh)
ref.ext_Info() << "\nStarting time loop\n" << ref.nl
while runTime.run():
adjustTimeStep, maxCo, maxDeltaT = ref.readTimeControls(runTime)
CoNum, meanCoNum = ref.CourantNo(mesh, phi, runTime)
runTime = ref.setDeltaT(runTime, adjustTimeStep, maxCo, maxDeltaT,
CoNum)
runTime.increment()
ref.ext_Info() << "Time = " << runTime.timeName() << ref.nl << ref.nl
# --- Pressure-velocity PIMPLE corrector loop
while pimple.loop():
UEqn, rAU = Ueqn(mesh, pimple, phi, U, p, turbulence, sources)
# --- Pressure corrector loop
while pimple.correct():
cumulativeContErr = pEqn(runTime, mesh, pimple, U, rAU, UEqn,
phi, p, pRefCell, pRefValue,
cumulativeContErr, sources)
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 )
p, U, Urel, SRF, phi, turbulence, pRefCell, pRefValue, laminarTransport, sources = _createFields( runTime, mesh )
cumulativeContErr = ref.initContinuityErrs()
pimple = man.pimpleControl( mesh )
ref.ext_Info() << "\nStarting time loop\n" <<ref.nl
while runTime.run() :
adjustTimeStep, maxCo, maxDeltaT = ref.readTimeControls( runTime )
CoNum, meanCoNum = ref.CourantNo( mesh, phi, runTime )
runTime = ref.setDeltaT( runTime, adjustTimeStep, maxCo, maxDeltaT, CoNum )
runTime.increment()
ref.ext_Info() << "Time = " << runTime.timeName() << ref.nl << ref.nl
# --- Pressure-velocity PIMPLE corrector loop
while pimple.loop():
UrelEqn = _UrelEqn( mesh, pimple, phi, Urel, p, turbulence, SRF, sources )
# --- Pressure corrector loop
while pimple.correct():
cumulativeContErr = pEqn( runTime, mesh, pimple, Urel, UrelEqn, phi, p, pRefCell, pRefValue, cumulativeContErr, sources )
pass
# Update the absolute velocity
U << Urel() + SRF.U() # mixed calculations
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 )
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 main_standalone(argc, argv):
args = ref.setRootCase(argc, argv)
runTime = man.createTime(args)
mesh = man.createMesh(runTime)
g = man.readGravitationalAcceleration(runTime, mesh)
pimple = ref.pimpleControl(mesh)
adjustTimeStep, maxCo, maxDeltaT, nAlphaCorr, nAlphaSubCycles = read_controls(
args, runTime, pimple)
cumulativeContErr = ref.initContinuityErrs()
p_rgh, alpha1, alpha2, U, phi, twoPhaseProperties, rho10, rho20, psi1, psi2, pMin, \
gh, ghf, p, rho1, rho2, rho, rhoPhi, dgdt, interface, turbulence = _createFields( runTime, mesh, g )
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, nAlphaCorr, nAlphaSubCycles = read_controls(
args, runTime, pimple)
CoNum, meanCoNum = ref.CourantNo(mesh, phi, runTime)
runTime = ref.setDeltaT(runTime, adjustTimeStep, maxCo, maxDeltaT,
CoNum)
runTime.increment()
ref.ext_Info() << "Time = " << runTime.timeName() << ref.nl << ref.nl
# --- Outer-corrector loop
pimple.start()
while pimple.loop():
alphaEqnsSubCycle(runTime, pimple, mesh, phi, alpha1, alpha2, rho,
rho1, rho2, rhoPhi, dgdt, interface)
ref.solve(ref.fvm.ddt(rho) + ref.fvc.div(rhoPhi))
UEqn = fun_UEqn(mesh, alpha1, U, p, p_rgh, ghf, rho, rhoPhi,
turbulence, g, twoPhaseProperties, interface,
pimple)
# --- PISO loop
for corr in range(pimple.nCorr()):
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 )
pass
if pimple.turbCorr():
turbulence.correct()
pass
pimple.increment()
pass
rho << alpha1 * rho1 + alpha2 * rho2
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)
pimple = man.pimpleControl(mesh)
maxDeltaT, rDeltaT = setInitialrDeltaT(runTime, mesh, pimple)
pThermo, p, h, psi, rho, U, phi, rhoMax, rhoMin, turbulence, dpdt, K = createFields(
runTime, mesh, pimple)
mrfZones, pZones, pressureImplicitPorosity = createZones(mesh, U)
cumulativeContErr = ref.initContinuityErrs()
ref.ext_Info() << "\nStarting time loop\n" << ref.nl
while runTime.run():
adjustTimeStep, maxCo, maxDeltaT = ref.readTimeControls(runTime)
CoNum, meanCoNum = ref.compressibleCourantNo(mesh, phi, rho, runTime)
runTime = ref.setDeltaT(runTime, adjustTimeStep, maxCo, maxDeltaT,
CoNum)
runTime.increment()
ref.ext_Info() << "Time = " << runTime.timeName() << ref.nl << ref.nl
setrDeltaT(runTime, mesh, pimple, phi, psi, U, rho, rDeltaT, maxDeltaT)
ref.rhoEqn(rho, phi)
# --- Pressure-velocity PIMPLE corrector loop
while pimple.loop():
turbulence.correct()
UEqn = fun_Ueqn(pimple, rho, p, U, phi, turbulence, mrfZones,
pZones)
fun_hEqn(pThermo, rho, p, h, phi, turbulence, dpdt, K)
# --- PISO loop
while (pimple.correct()):
cumulativeContErr = fun_pEqn(mesh, runTime, pimple, pThermo,
rho, p, h, psi, U, phi, mrfZones,
turbulence, UEqn, dpdt, K,
cumulativeContErr, rhoMax, rhoMin)
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.createDynamicFvMesh(runTime)
cumulativeContErr = ref.initContinuityErrs()
p, U, phi, laminarTransport, turbulence, rAU, pRefCell, pRefValue, sources = _createFields(
runTime, mesh)
adjustTimeStep, maxCo, maxDeltaT = ref.readTimeControls(runTime)
pimple = man.pimpleControl(mesh)
ref.ext_Info() << "\nStarting time loop\n" << ref.nl
while runTime.run():
adjustTimeStep, maxCo, maxDeltaT, pimpleDic, correctPhi, checkMeshCourantNo, ddtPhiCorr = readControls(
runTime, mesh, pimple)
CoNum, meanCoNum = ref.CourantNo(mesh, phi, runTime)
# Make the fluxes absolute
ref.fvc.makeAbsolute(phi, U)
runTime = ref.setDeltaT(runTime, adjustTimeStep, maxCo, maxDeltaT,
CoNum)
runTime.increment()
ref.ext_Info() << "Time = " << runTime.timeName() << ref.nl << ref.nl
mesh.update()
if mesh.changing() and correctPhi:
cumulativeContErr = _correctPhi(runTime, mesh, pimple, p, U, rAU,
phi, pRefCell, pRefValue,
cumulativeContErr)
pass
# Make the fluxes relative to the mesh motion
ref.fvc.makeRelative(phi, U)
if mesh.changing() and checkMeshCourantNo:
meshCoNum, meanMeshCoNum = ref.meshCourantNo(runTime, mesh, phi)
pass
# --- Pressure-velocity PIMPLE corrector loop
while pimple.loop():
UEqn = fun_UEqn(mesh, phi, U, p, rAU, turbulence, pimple)
# --- Pressure corrector loop
while pimple.correct():
cumulativeContErr = fun_pEqn(mesh, runTime, pimple, U, phi,
turbulence, p, rAU, UEqn,
pRefCell, pRefValue,
cumulativeContErr, ddtPhiCorr)
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.createDynamicFvMesh( runTime )
cumulativeContErr = ref.initContinuityErrs()
p, U, phi, laminarTransport, turbulence, rAU, pRefCell, pRefValue, sources = _createFields( runTime, mesh )
adjustTimeStep, maxCo, maxDeltaT = ref.readTimeControls( runTime )
pimple = man.pimpleControl( mesh )
ref.ext_Info() << "\nStarting time loop\n" <<ref.nl
while runTime.run() :
adjustTimeStep, maxCo, maxDeltaT, pimpleDic, correctPhi, checkMeshCourantNo, ddtPhiCorr = readControls( runTime, mesh, pimple )
CoNum, meanCoNum = ref.CourantNo( mesh, phi, runTime )
# Make the fluxes absolute
ref.fvc.makeAbsolute(phi, U)
runTime = ref.setDeltaT( runTime, adjustTimeStep, maxCo, maxDeltaT, CoNum )
runTime.increment()
ref.ext_Info() << "Time = " << runTime.timeName() << ref.nl << ref.nl
mesh.update()
if mesh.changing() and correctPhi :
cumulativeContErr = _correctPhi( runTime, mesh, pimple, p, U, rAU, phi, pRefCell, pRefValue, cumulativeContErr )
pass
# Make the fluxes relative to the mesh motion
ref.fvc.makeRelative( phi, U )
if mesh.changing() and checkMeshCourantNo :
meshCoNum, meanMeshCoNum = ref.meshCourantNo( runTime, mesh, phi )
pass
# --- Pressure-velocity PIMPLE corrector loop
while pimple.loop():
UEqn = fun_UEqn( mesh, phi, U, p, rAU, turbulence, pimple, sources )
# --- Pressure corrector loop
while pimple.correct():
cumulativeContErr = fun_pEqn( mesh, runTime, pimple, U, phi, turbulence, p, rAU, UEqn, pRefCell, pRefValue, cumulativeContErr, ddtPhiCorr, sources )
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 )
g = readGravitationalAcceleration( runTime, mesh );
T, p_rgh, U, phi, laminarTransport, turbulence, rhok, \
kappat, gh, ghf, p, pRefCell, pRefValue, beta, TRef, Pr, Prt = createFields( runTime, mesh, g )
cumulativeContErr = ref.initContinuityErrs()
adjustTimeStep, maxCo, maxDeltaT = ref.readTimeControls( runTime )
CoNum, meanCoNum = ref.CourantNo( mesh, phi, runTime )
runTime = ref.setInitialDeltaT( runTime, adjustTimeStep, maxCo, CoNum )
pimple = man.pimpleControl( mesh )
# * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * #
ref.ext_Info() << "\nStarting time loop\n" << ref.nl
while runTime.loop():
ref.ext_Info() << "Time = " << runTime.timeName() << ref.nl << ref.nl
adjustTimeStep, maxCo, maxDeltaT = ref.readTimeControls( runTime )
CoNum, meanCoNum = ref.CourantNo( mesh, phi, runTime )
runTime = ref.setDeltaT( runTime, adjustTimeStep, maxCo, maxDeltaT, CoNum )
# Pressure-velocity PIMPLE corrector loop
while pimple.loop():
UEqn = fun_UEqn( mesh, pimple, U, phi, turbulence, p, rhok, p_rgh, ghf )
fun_TEqn( phi, turbulence, kappat, T, rhok, beta, TRef, Prt, Pr )
# --- Pressure corrector loop
while pimple.correct():
cumulativeContErr = fun_pEqn( mesh, runTime, pimple, p, rhok, U, phi, turbulence, gh, ghf, p_rgh, UEqn, 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
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)
g = ref.readGravitationalAcceleration(runTime, mesh)
thermo, p, rho, h, psi, U, phi, turbulence, gh, ghf, p_rgh, dpdt, K = createFields(
runTime, mesh, g)
cumulativeContErr = ref.initContinuityErrs()
adjustTimeStep, maxCo, maxDeltaT = ref.readTimeControls(runTime)
CoNum, meanCoNum = ref.compressibleCourantNo(mesh, phi, rho, runTime)
runTime = ref.setInitialDeltaT(runTime, adjustTimeStep, maxCo, CoNum)
pimple = man.pimpleControl(mesh)
# * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
ref.ext_Info() << "\nStarting time loop\n" << ref.nl
while runTime.run():
adjustTimeStep, maxCo, maxDeltaT = ref.readTimeControls(runTime)
CoNum, meanCoNum = ref.compressibleCourantNo(mesh, phi, rho, runTime)
runTime = ref.setDeltaT(runTime, adjustTimeStep, maxCo, maxDeltaT,
CoNum)
runTime.increment()
ref.ext_Info() << "Time = " << runTime.timeName() << ref.nl << ref.nl
ref.rhoEqn(rho, phi)
# --- Pressure-velocity PIMPLE corrector loop
while pimple.loop():
UEqn = fun_Ueqn(pimple, mesh, rho, U, phi, turbulence, ghf, p_rgh,
K)
fun_hEqn(thermo, rho, p, h, phi, turbulence, dpdt, K)
# --- Pressure corrector loop
while pimple.correct():
cumulativeContErr = fun_pEqn(mesh, runTime, pimple, thermo,
rho, p, h, psi, U, phi,
turbulence, gh, ghf, p_rgh, UEqn,
dpdt, K, cumulativeContErr)
pass
if pimple.turbCorr():
turbulence.correct()
pass
pass
rho << thermo.rho()
runTime.write()
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 )
g = man.readGravitationalAcceleration( runTime, mesh)
pimple = ref.pimpleControl( mesh )
adjustTimeStep, maxCo, maxDeltaT, nAlphaCorr, nAlphaSubCycles = read_controls( args, runTime, pimple )
cumulativeContErr = ref.initContinuityErrs()
p_rgh, alpha1, alpha2, U, phi, twoPhaseProperties, rho10, rho20, psi1, psi2, pMin, \
gh, ghf, p, rho1, rho2, rho, rhoPhi, dgdt, interface, turbulence = _createFields( runTime, mesh, g )
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, nAlphaCorr, nAlphaSubCycles = read_controls( args, runTime, pimple )
CoNum, meanCoNum = ref.CourantNo( mesh, phi, runTime )
runTime = ref.setDeltaT( runTime, adjustTimeStep, maxCo, maxDeltaT, CoNum )
runTime.increment()
ref.ext_Info() << "Time = " << runTime.timeName() << ref.nl << ref.nl
# --- Outer-corrector loop
while pimple.loop():
alphaEqnsSubCycle( runTime, pimple, mesh, phi, alpha1, alpha2, rho, rho1, rho2, rhoPhi, dgdt, interface )
ref.solve( ref.fvm.ddt( rho ) + ref.fvc.div( rhoPhi ) )
UEqn = fun_UEqn( mesh, alpha1, U, p, p_rgh, ghf, rho, rhoPhi, turbulence, g, twoPhaseProperties, interface, pimple )
# --- Pressure corrector loop
while pimple.correct():
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 )
pass
if pimple.turbCorr():
turbulence.correct()
pass
pass
rho << alpha1 * rho1 + alpha2 * rho2
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)
g = ref.readGravitationalAcceleration(runTime, mesh)
thermo, p, rho, h, psi, U, phi, turbulence, gh, ghf, p_rgh, DpDt = createFields(runTime, mesh, g)
cumulativeContErr = ref.initContinuityErrs()
adjustTimeStep, maxCo, maxDeltaT = ref.readTimeControls(runTime)
CoNum, meanCoNum = ref.compressibleCourantNo(mesh, phi, rho, runTime)
runTime = ref.setInitialDeltaT(runTime, adjustTimeStep, maxCo, CoNum)
pimple = man.pimpleControl(mesh)
# * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
ref.ext_Info() << "\nStarting time loop\n" << ref.nl
while runTime.run():
adjustTimeStep, maxCo, maxDeltaT = ref.readTimeControls(runTime)
CoNum, meanCoNum = ref.compressibleCourantNo(mesh, phi, rho, runTime)
runTime = ref.setDeltaT(runTime, adjustTimeStep, maxCo, maxDeltaT, CoNum)
runTime.increment()
ref.ext_Info() << "Time = " << runTime.timeName() << ref.nl << ref.nl
ref.rhoEqn(rho, phi)
# --- Pressure-velocity PIMPLE corrector loop
pimple.start()
while pimple.loop():
if pimple.nOuterCorr() != 1:
p_rgh.storePrevIter()
pass
UEqn = fun_Ueqn(pimple, mesh, rho, U, phi, turbulence, ghf, p_rgh)
fun_hEqn(thermo, rho, p, h, phi, turbulence, DpDt)
# --- PISO loop
for corr in range(pimple.nCorr()):
cumulativeContErr = fun_pEqn(
mesh,
runTime,
pimple,
thermo,
rho,
p,
h,
psi,
U,
phi,
turbulence,
gh,
ghf,
p_rgh,
UEqn,
DpDt,
cumulativeContErr,
corr,
)
pass
if pimple.turbCorr():
turbulence.correct()
pass
pimple.increment()
pass
rho << thermo.rho()
runTime.write()
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 )
g = man.readGravitationalAcceleration( runTime, mesh )
cumulativeContErr = ref.initContinuityErrs()
p_rgh, alpha1, U, phi, twoPhaseProperties, rho1, rho2, Dab, \
alphatab, rho, rhoPhi, turbulence, gh, ghf, p, pRefCell, pRefValue = _createFields( runTime, mesh, g )
adjustTimeStep, maxCo, maxDeltaT = ref.readTimeControls( runTime )
CoNum, meanCoNum = ref.CourantNo( mesh, phi, runTime )
runTime = ref.setInitialDeltaT( runTime, adjustTimeStep, maxCo, CoNum )
pimple = man.pimpleControl( mesh )
ref.ext_Info() << "\nStarting time loop\n" << ref.nl
while runTime.run():
adjustTimeStep, maxCo, maxDeltaT = ref.readTimeControls( runTime )
CoNum, meanCoNum = ref.CourantNo( mesh, phi, runTime )
runTime = ref.setDeltaT( runTime, adjustTimeStep, maxCo, maxDeltaT, CoNum )
runTime.increment()
ref.ext_Info() << "Time = " << runTime.timeName() << ref.nl << ref.nl
# --- Pressure-velocity PIMPLE corrector loop
pimple.start()
while pimple.loop():
twoPhaseProperties.correct()
alphaEqn( mesh, phi, alpha1, alphatab, Dab, rhoPhi, rho, rho1, rho2, turbulence )
UEqn = fun_UEqn( mesh, U, p_rgh, ghf, rho, rhoPhi, turbulence, twoPhaseProperties, pimple )
# --- PISO loop
for corr in range( pimple.nCorr() ):
cumulativeContErr = fun_pEqn( runTime, mesh, UEqn, U, p, p_rgh, gh, ghf, phi, rho, pimple, \
corr, pRefCell, pRefValue, cumulativeContErr )
pass
if pimple.turbCorr():
turbulence.correct()
pass
pimple.increment()
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 )
pThermo, p, h, psi, rho, U, phi, rhoMax, rhoMin, turbulence, DpDt = createFields( runTime, mesh )
cumulativeContErr = ref.initContinuityErrs()
pimple = man.pimpleControl(mesh)
ref.ext_Info()<< "\nStarting time loop\n" << ref.nl;
while runTime.run():
adjustTimeStep, maxCo, maxDeltaT = ref.readTimeControls( runTime )
CoNum, meanCoNum = ref.compressibleCourantNo( mesh, phi, rho, runTime )
runTime = ref.setDeltaT( runTime, adjustTimeStep, maxCo, maxDeltaT, CoNum )
runTime.increment()
ref.ext_Info()<< "Time = " << runTime.timeName() << ref.nl << ref.nl;
ref.rhoEqn( rho, phi )
# --- Pressure-velocity PIMPLE corrector loop
pimple.start()
while pimple.loop():
if pimple.nOuterCorr() != 1:
p.storePrevIter()
rho.storePrevIter()
pass
UEqn, rAU = fun_Ueqn( pimple, rho, p, U, phi, turbulence )
fun_hEqn( pThermo, rho, p, h, phi, turbulence, DpDt )
# --- PISO loop
for corr in range( pimple.nCorr() ):
cumulativeContErr = fun_pEqn( mesh, runTime, pimple, pThermo, rho, p, h, psi, U, phi,
turbulence, UEqn, rAU, DpDt, cumulativeContErr, corr, rhoMax, rhoMin )
pass
if pimple.turbCorr():
turbulence.correct()
pass
pimple.increment()
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
