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 readControls(runTime, mesh, pimple):
adjustTimeStep, maxCo, maxDeltaT = ref.readTimeControls(runTime)
correctPhi = pimple.dict().lookupOrDefault(ref.word("correctPhi"), ref.Switch(True))
checkMeshCourantNo = pimple.dict().lookupOrDefault(ref.word("checkMeshCourantNo"), ref.Switch(False))
return adjustTimeStep, maxCo, maxDeltaT, correctPhi, checkMeshCourantNo
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 readControls(runTime, mesh, pimple):
adjustTimeStep, maxCo, maxDeltaT = ref.readTimeControls(runTime)
pimpleDict = pimple.dict()
correctPhi = pimpleDict.lookupOrDefault(ref.word("correctPhi"),
ref.Switch(False))
checkMeshCourantNo = pimpleDict.lookupOrDefault(
ref.word("checkMeshCourantNo"), ref.Switch(False))
return adjustTimeStep, maxCo, maxDeltaT, pimpleDict, correctPhi, checkMeshCourantNo
def read_controls( args, runTime, pimple ):
adjustTimeStep, maxCo, maxDeltaT = ref.readTimeControls( runTime )
nAlphaCorr = ref.readLabel( pimple.dict().lookup( ref.word( "nAlphaCorr" ) ) )
nAlphaSubCycles = ref.readLabel( pimple.dict().lookup( ref.word( "nAlphaSubCycles" ) ) )
if nAlphaSubCycles > 1 and nCorrPIMPLE != 1:
from Foam.OpenFOAM import ext_Info, nl
ref.ext_Info() << args.executable() << "FATAL ERROR: Sub-cycling alpha is only allowed for PISO operations, i.e. when the number of outer-correctors = 1" << ref.nl;
import os; os_exit( 1 )
pass
return adjustTimeStep, maxCo, maxDeltaT, nAlphaCorr, nAlphaSubCycles
def read_controls(args, runTime, pimple):
adjustTimeStep, maxCo, maxDeltaT = ref.readTimeControls(runTime)
nAlphaCorr = ref.readLabel(pimple.dict().lookup(ref.word("nAlphaCorr")))
nAlphaSubCycles = ref.readLabel(pimple.dict().lookup(
ref.word("nAlphaSubCycles")))
if nAlphaSubCycles > 1 and nOuterCorr != 1:
from Foam.OpenFOAM import ext_Info, nl
ref.ext_Info() << args.executable(
) << "FATAL ERROR: Sub-cycling alpha is only allowed for PISO, i.e. when the number of outer-correctors = 1" << ref.nl
import os
os_exit(1)
pass
return adjustTimeStep, maxCo, maxDeltaT, nAlphaCorr, nAlphaSubCycles
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 )
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
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.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 )
pimple = man.pimpleControl( mesh )
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 )
cumulativeContErr = correctPhi( runTime, mesh, phi, 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 = ref.readTimeControls( runTime )
CoNum, meanCoNum = ref.CourantNo( mesh, phi, runTime )
maxAlphaCo, alphaCoNum, meanAlphaCoNum = alphaCourantNo( runTime, mesh, alpha1, phi )
runTime = setDeltaT( runTime, adjustTimeStep, maxCo, CoNum, maxAlphaCo, alphaCoNum, maxDeltaT )
runTime.increment()
ref.ext_Info() << "Time = " << runTime.timeName() << ref.nl << ref.nl
twoPhaseProperties.correct()
alphaEqnSubCycle( runTime, pimple, mesh, phi, alpha1, rho, rhoPhi, rho1, rho2, interface )
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, 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.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 )
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 = 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 )
rp = ref.compressible.regionProperties( runTime )
from fluid import createFluidMeshes
fluidRegions = createFluidMeshes( rp, runTime )
from solid import createSolidMeshes,createSolidField
solidRegions = createSolidMeshes( rp,runTime )
from fluid import createFluidFields
thermoFluid, rhoFluid, kappaFluid, UFluid, phiFluid, gFluid, turbulence, KFluid, \
dpdtFluid, initialMassFluid, ghFluid, ghfFluid, p_rghFluid, radiation = createFluidFields( fluidRegions, runTime )
from solid import createSolidField
thermos = createSolidField( solidRegions, runTime )
from fluid import initContinuityErrs
cumulativeContErr = initContinuityErrs( fluidRegions )
adjustTimeStep, maxCo, maxDeltaT = ref.readTimeControls( runTime )
from solid import readSolidTimeControls
maxDi= readSolidTimeControls( runTime )
from fluid import compressubibleMultiRegionCourantNo
CoNum = compressubibleMultiRegionCourantNo( fluidRegions, runTime, rhoFluid, phiFluid )
from solid import solidRegionDiffusionNo
DiNum = solidRegionDiffusionNo( solidRegions, runTime, thermos )
runTime, CoNum, DiNum = setInitialMultiRegionDeltaT( adjustTimeStep, runTime, CoNum, DiNum, maxCo, maxDi, maxDeltaT )
while runTime.run() :
adjustTimeStep, maxCo, maxDeltaT = ref.readTimeControls(runTime)
maxDi= readSolidTimeControls( runTime )
nOuterCorr = readPIMPLEControls( runTime )
CoNum = compressubibleMultiRegionCourantNo( fluidRegions, runTime, rhoFluid, phiFluid )
DiNum = solidRegionDiffusionNo( solidRegions, runTime, thermos )
runTime, CoNum, DiNum = setMultiRegionDeltaT( adjustTimeStep, runTime, CoNum, DiNum, maxCo, maxDi, maxDeltaT )
runTime.increment()
ref.ext_Info()<< "Time = " << runTime.timeName() << ref.nl << ref.nl
if nOuterCorr != 1 :
for i in range( fluidRegions.__len__() ):
from fluid import setRegionFluidFields
mesh, thermo, rho, kappa, K, U, phi, turb, dpdt, p, psi, h, initialMass, p_rgh, gh, ghf, rad = \
setRegionFluidFields( i, fluidRegions, thermoFluid, rhoFluid, kappaFluid, UFluid, \
phiFluid, turbulence, KFluid, dpdtFluid, initialMassFluid, ghFluid, ghfFluid, p_rghFluid, radiation )
from fluid import storeOldFluidFields
storeOldFluidFields( p, rho )
pass
pass
# --- PIMPLE loop
for oCorr in range( nOuterCorr ):
finalIter = ( oCorr == nOuterCorr-1 )
for i in range( fluidRegions.__len__() ):
ref.ext_Info() << "\nSolving for fluid region " << fluidRegions[ i ].name() << ref.nl
from fluid import setRegionFluidFields
mesh, thermo, rho, kappa, K, U, phi, turb, dpdt, p, psi, h, initialMass, p_rgh, gh, ghf, rad = \
setRegionFluidFields( i, fluidRegions, thermoFluid, rhoFluid, kappaFluid, UFluid, \
phiFluid, turbulence, KFluid, dpdtFluid, initialMassFluid, ghFluid, ghfFluid, p_rghFluid, radiation )
from fluid import readFluidMultiRegionPIMPLEControls
pimple, nCorr, nNonOrthCorr, momentumPredictor = readFluidMultiRegionPIMPLEControls( mesh )
from fluid import solveFluid
cumulativeContErr = solveFluid( i, mesh, thermo, rad, thermoFluid, rho, kappa, K, U, phi, h, turb, dpdt, p, psi, initialMass, p_rgh, gh, \
ghf, oCorr, nCorr, nOuterCorr, nNonOrthCorr, momentumPredictor, cumulativeContErr, finalIter )
pass
for i in range( solidRegions.__len__() ):
ref.ext_Info() << "\nSolving for solid region " << solidRegions[ i ].name() << ref.nl
from solid import setRegionSolidFields
mesh, thermo, rho, cp, tkappa, kappa = setRegionSolidFields( i, solidRegions, thermos )
from solid import readSolidMultiRegionPIMPLEControls
pimple, nNonOrthCorr = readSolidMultiRegionPIMPLEControls( mesh )
from solid import solveSolid
solveSolid( mesh, thermo, rho, cp, tkappa, kappa, nNonOrthCorr, finalIter )
pass
pass
pass
runTime.write()
ref.ext_Info()<< "ExecutionTime = " << runTime.elapsedCpuTime() << " s" \
<< " ClockTime = " << runTime.elapsedClockTime() << " s" \
<< ref.nl << ref.nl
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 = 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)
rp = ref.compressible.regionProperties(runTime)
from fluid import createFluidMeshes
fluidRegions = createFluidMeshes(rp, runTime)
from solid import createSolidMeshes, createSolidField
solidRegions = createSolidMeshes(rp, runTime)
from fluid import createFluidFields
thermoFluid, rhoFluid, kappaFluid, UFluid, phiFluid, gFluid, turbulence, KFluid, \
dpdtFluid, initialMassFluid, ghFluid, ghfFluid, p_rghFluid, radiation = createFluidFields( fluidRegions, runTime )
from solid import createSolidField
thermos = createSolidField(solidRegions, runTime)
from fluid import initContinuityErrs
cumulativeContErr = initContinuityErrs(fluidRegions)
adjustTimeStep, maxCo, maxDeltaT = ref.readTimeControls(runTime)
from solid import readSolidTimeControls
maxDi = readSolidTimeControls(runTime)
from fluid import compressubibleMultiRegionCourantNo
CoNum = compressubibleMultiRegionCourantNo(fluidRegions, runTime, rhoFluid,
phiFluid)
from solid import solidRegionDiffusionNo
DiNum = solidRegionDiffusionNo(solidRegions, runTime, thermos)
runTime, CoNum, DiNum = setInitialMultiRegionDeltaT(
adjustTimeStep, runTime, CoNum, DiNum, maxCo, maxDi, maxDeltaT)
while runTime.run():
adjustTimeStep, maxCo, maxDeltaT = ref.readTimeControls(runTime)
maxDi = readSolidTimeControls(runTime)
nOuterCorr = readPIMPLEControls(runTime)
CoNum = compressubibleMultiRegionCourantNo(fluidRegions, runTime,
rhoFluid, phiFluid)
DiNum = solidRegionDiffusionNo(solidRegions, runTime, thermos)
runTime, CoNum, DiNum = setMultiRegionDeltaT(adjustTimeStep, runTime,
CoNum, DiNum, maxCo,
maxDi, maxDeltaT)
runTime.increment()
ref.ext_Info() << "Time = " << runTime.timeName() << ref.nl << ref.nl
if nOuterCorr != 1:
for i in range(fluidRegions.__len__()):
from fluid import setRegionFluidFields
mesh, thermo, rho, kappa, K, U, phi, turb, dpdt, p, psi, h, initialMass, p_rgh, gh, ghf, rad = \
setRegionFluidFields( i, fluidRegions, thermoFluid, rhoFluid, kappaFluid, UFluid, \
phiFluid, turbulence, KFluid, dpdtFluid, initialMassFluid, ghFluid, ghfFluid, p_rghFluid, radiation )
from fluid import storeOldFluidFields
storeOldFluidFields(p, rho)
pass
pass
# --- PIMPLE loop
for oCorr in range(nOuterCorr):
finalIter = (oCorr == nOuterCorr - 1)
for i in range(fluidRegions.__len__()):
ref.ext_Info(
) << "\nSolving for fluid region " << fluidRegions[i].name(
) << ref.nl
from fluid import setRegionFluidFields
mesh, thermo, rho, kappa, K, U, phi, turb, dpdt, p, psi, h, initialMass, p_rgh, gh, ghf, rad = \
setRegionFluidFields( i, fluidRegions, thermoFluid, rhoFluid, kappaFluid, UFluid, \
phiFluid, turbulence, KFluid, dpdtFluid, initialMassFluid, ghFluid, ghfFluid, p_rghFluid, radiation )
from fluid import readFluidMultiRegionPIMPLEControls
pimple, nCorr, nNonOrthCorr, momentumPredictor = readFluidMultiRegionPIMPLEControls(
mesh)
from fluid import solveFluid
cumulativeContErr = solveFluid( i, mesh, thermo, rad, thermoFluid, rho, kappa, K, U, phi, h, turb, dpdt, p, psi, initialMass, p_rgh, gh, \
ghf, oCorr, nCorr, nOuterCorr, nNonOrthCorr, momentumPredictor, cumulativeContErr, finalIter )
pass
for i in range(solidRegions.__len__()):
ref.ext_Info(
) << "\nSolving for solid region " << solidRegions[i].name(
) << ref.nl
from solid import setRegionSolidFields
mesh, thermo, rho, cp, tkappa, kappa = setRegionSolidFields(
i, solidRegions, thermos)
from solid import readSolidMultiRegionPIMPLEControls
pimple, nNonOrthCorr = readSolidMultiRegionPIMPLEControls(mesh)
from solid import solveSolid
solveSolid(mesh, thermo, rho, cp, tkappa, kappa, nNonOrthCorr,
finalIter)
pass
pass
pass
runTime.write()
ref.ext_Info()<< "ExecutionTime = " << runTime.elapsedCpuTime() << " s" \
<< " ClockTime = " << runTime.elapsedClockTime() << " s" \
<< ref.nl << ref.nl
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)
pimple = man.pimpleControl(mesh)
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)
cumulativeContErr = correctPhi(runTime, mesh, phi, 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 = ref.readTimeControls(runTime)
CoNum, meanCoNum = ref.CourantNo(mesh, phi, runTime)
maxAlphaCo, alphaCoNum, meanAlphaCoNum = alphaCourantNo(
runTime, mesh, alpha1, phi)
runTime = setDeltaT(runTime, adjustTimeStep, maxCo, CoNum, maxAlphaCo,
alphaCoNum, maxDeltaT)
runTime.increment()
ref.ext_Info() << "Time = " << runTime.timeName() << ref.nl << ref.nl
twoPhaseProperties.correct()
alphaEqnSubCycle(runTime, pimple, mesh, phi, alpha1, rho, rhoPhi, rho1,
rho2, interface)
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, 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 )
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
