def _UEqn(mesh, alpha1, U, p, p_rgh, ghf, rho, rhoPhi, turbulence, g, twoPhaseProperties, interface, pimple):
muEff = ref.surfaceScalarField(
ref.word("muEff"), twoPhaseProperties.muf() + ref.fvc.interpolate(rho * turbulence.ext_nut())
)
UEqn = (
ref.fvm.ddt(rho, U)
+ ref.fvm.div(rhoPhi, U)
- ref.fvm.laplacian(muEff, U)
- (ref.fvc.grad(U) & ref.fvc.grad(muEff))
)
UEqn.relax()
if pimple.momentumPredictor():
ref.solve(
UEqn
== ref.fvc.reconstruct(
(
ref.fvc.interpolate(interface.sigmaK()) * ref.fvc.snGrad(alpha1)
- ghf * ref.fvc.snGrad(rho)
- ref.fvc.snGrad(p_rgh)
)
* mesh.magSf()
)
)
pass
return UEqn
def main_standalone(argc, argv):
args = ref.setRootCase(argc, argv)
runTime = man.createTime(args)
mesh = man.createMesh(runTime)
T, U, transportProperties, DT, phi = _createFields(runTime, mesh)
simple = man.simpleControl(mesh)
ref.ext_Info() << "\nCalculating scalar transport\n" << ref.nl
CoNum, meanCoNum = ref.CourantNo(mesh, phi, runTime)
while simple.loop():
ref.ext_Info() << "Time = " << runTime.timeName() << ref.nl << ref.nl
while simple.correctNonOrthogonal():
ref.solve(
ref.fvm.ddt(T) + ref.fvm.div(phi, T) -
ref.fvm.laplacian(DT, T))
pass
runTime.write()
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 )
T, transportProperties, DT = _createFields( runTime, mesh )
simple = man.simpleControl( mesh )
ref.ext_Info() << "\nCalculating temperature distribution\n" << ref.nl
while runTime.loop() :
ref.ext_Info() << "Time = " << runTime.timeName() << ref.nl << ref.nl
for nonOrth in range( simple.nNonOrthCorr() + 1 ):
ref.solve( ref.fvm.ddt( T ) - ref.fvm.laplacian( DT, T ) )
pass
write( runTime, mesh, T )
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)
T, transportProperties, DT = _createFields(runTime, mesh)
simple = man.simpleControl(mesh)
ref.ext_Info() << "\nCalculating temperature distribution\n" << ref.nl
while runTime.loop():
ref.ext_Info() << "Time = " << runTime.timeName() << ref.nl << ref.nl
while simple.correctNonOrthogonal():
ref.solve(ref.fvm.ddt(T) - ref.fvm.laplacian(DT, T))
pass
write(runTime, mesh, T)
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 )
T, U, transportProperties, DT, phi = _createFields( runTime, mesh )
simple = man.simpleControl( mesh )
ref.ext_Info() << "\nCalculating scalar transport\n" << ref.nl
CoNum, meanCoNum = ref.CourantNo( mesh, phi, runTime )
while simple.loop():
ref.ext_Info() << "Time = " << runTime.timeName() << ref.nl << ref.nl
for nonOrth in range ( simple.nNonOrthCorr() + 1 ):
ref.solve( ref.fvm.ddt( T ) + ref.fvm.div( phi, T ) - ref.fvm.laplacian( DT, T ) )
pass
runTime.write()
pass
ref.ext_Info() << "End\n" << ref.nl
import os
return os.EX_OK
def _UEqn( phi, U, p, rho, turbulence, mrfZones, pZones, pressureImplicitPorosity, nUCorr ):
# Solve the Momentum equation
UEqn = man.fvVectorMatrix( turbulence.divDevRhoReff( U ), man.Deps( turbulence ) ) + man.fvm.div( phi, U )
UEqn.relax()
mrfZones.addCoriolis( rho, UEqn )
trAU = None
trTU = None
if pressureImplicitPorosity:
tTU = man.volTensorField( ref.tensor( ref.I ) * UEqn.A(), man.Deps( UEqn ) )
pZones.addResistance( UEqn, tTU )
trTU = man.volTensorField( tTU.inv(), man.Deps( tTU ) )
trTU.rename( ref.word( "rAU" ) )
gradp = ref.fvc.grad(p)
for UCorr in range( nUCorr ):
U << ( trTU() & ( UEqn.H() - gradp ) ) # mixed calculations
pass
U.correctBoundaryConditions()
pass
else:
pZones.addResistance( UEqn )
ref.solve( UEqn == -ref.fvc.grad( p ) )
trAU = man.volScalarField( 1.0 / UEqn.A(), man.Deps( UEqn ) )
trAU.rename( ref.word( "rAU" ) )
pass
return UEqn, trAU, trTU
def fun_eEqn(rho, e, phi, turbulence, p, thermo):
ref.solve(
ref.fvm.ddt(rho, e) + ref.fvm.div(phi, e) -
ref.fvm.laplacian(turbulence.alphaEff(), e) == -p() *
ref.fvc.div(phi() / ref.fvc.interpolate(rho))) # mixed calculation
thermo.correct()
pass
def _UEqn( phi, U, p, rho, turbulence ):
# Solve the Momentum equation
UEqn = man.fvVectorMatrix( turbulence.divDevRhoReff( U ), man.Deps( turbulence ) ) + man.fvm.div( phi, U )
UEqn.relax()
ref.solve( UEqn == -ref.fvc.grad( p ) )
return UEqn
def fun_UEqn( U, phi, turbulence, p ): # Solve the Momentum equation UEqn = man.fvm.div( phi, U ) + man( turbulence.divDevReff( U ), man.Deps( turbulence, U ) ) UEqn.relax() ref.solve( UEqn == -man.fvc.grad( p ) ) return UEqn
def fun_Ueqn( simple, mesh, rho, U, phi, turbulence, ghf, p_rgh ):
UEqn = man.fvm.div( phi, U ) + man( turbulence.divDevRhoReff( U ), man.Deps( turbulence, U) )
UEqn.relax()
if simple.momentumPredictor():
ref.solve( UEqn == man.fvc.reconstruct( ( ( - ghf * man.fvc.snGrad( rho ) - man.fvc.snGrad( p_rgh ) ) * man.surfaceScalarField( mesh.magSf(), man.Deps( mesh ) ) ) ) )
return UEqn
def fun_UEqn( mesh, pimple, U, phi, turbulence, p, rhok, p_rgh, ghf ):
UEqn = man.fvm.ddt( U ) + man.fvm.div(phi, U) + man( turbulence.divDevReff( U ) , man.Deps( U ) )
UEqn.relax()
if pimple.momentumPredictor():
ref.solve( UEqn == man.fvc.reconstruct( ( - ghf * man.fvc.snGrad( rhok ) - man.fvc.snGrad( p_rgh ) ) * man.surfaceScalarField( mesh.magSf(), mesh ) ) )
pass
return UEqn
def fun_UEqn( mesh, simple, U, phi, turbulence, p, rhok, p_rgh, ghf ):
UEqn = man.fvm.div(phi, U) + man( turbulence.divDevReff( U ) , man.Deps( U ) )
UEqn.relax()
if simple.momentumPredictor():
ref.solve( UEqn == man.fvc.reconstruct( ( - ghf * man.fvc.snGrad( rhok ) - man.fvc.snGrad( p_rgh ) ) * man.surfaceScalarField( mesh.magSf(), mesh ) ) )
pass
return UEqn
def fun_UEqn( rho, U, phi, ghf, p_rgh, turb, mesh ):
# Solve the Momentum equation
UEqn = man.fvm.div( phi, U ) + man.fvVectorMatrix( turb.divDevRhoReff( U ), man.Deps( turb, U ) )
UEqn.relax()
ref.solve( UEqn() == ref.fvc.reconstruct( ( -ghf * ref.fvc.snGrad( rho ) - ref.fvc.snGrad( p_rgh ) ) * mesh.magSf() ) )
return UEqn
def fun_UEqn(U, phi, turbulence, p):
# Solve the Momentum equation
UEqn = man.fvm.div(phi, U) + man(turbulence.divDevReff(U),
man.Deps(turbulence, U))
UEqn.relax()
ref.solve(UEqn == -man.fvc.grad(p))
return UEqn
def fun_pEqn( runTime, mesh, pimple, UEqn, p, p_rgh, phi, U, rho, rho1, rho2, rho10, rho20, gh, ghf, dgdt, pMin, \
psi1, psi2, alpha1, alpha2, interface, corr ):
rAU = 1.0 / UEqn.A()
rAUf = ref.fvc.interpolate(rAU)
p_rghEqnComp = None
if pimple.transonic():
p_rghEqnComp = ref.fvm.ddt(p_rgh) + ref.fvm.div(
phi, p_rgh) - ref.fvm.Sp(ref.fvc.div(phi), p_rgh)
pass
else:
p_rghEqnComp = ref.fvm.ddt(p_rgh) + ref.fvc.div(
phi, p_rgh) - ref.fvc.Sp(ref.fvc.div(phi), p_rgh)
pass
U << rAU * UEqn.H()
phiU = ref.surfaceScalarField(ref.word("phiU"),
(ref.fvc.interpolate(U) & mesh.Sf()) +
ref.fvc.ddtPhiCorr(rAU, rho, U, phi))
phi << (phiU +
(ref.fvc.interpolate(interface.sigmaK()) * ref.fvc.snGrad(alpha1) -
ghf * ref.fvc.snGrad(rho)) * rAUf * mesh.magSf())
for nonOrth in range(pimple.nNonOrthCorr() + 1):
p_rghEqnIncomp = ref.fvc.div(phi) - ref.fvm.laplacian(rAUf, p_rgh)
ref.solve(
(alpha1.ext_max(0.0) * (psi1 / rho1) + alpha2.ext_max(0.0) *
(psi2 / rho2)) * p_rghEqnComp() + p_rghEqnIncomp, ##
mesh.solver(p_rgh.select(pimple.finalInnerIter(corr, nonOrth))))
if nonOrth == pimple.nNonOrthCorr():
dgdt << (alpha2.pos() * (psi2 / rho2) - alpha1.pos() *
(psi1 / rho1)) * (p_rghEqnComp & p_rgh)
phi += p_rghEqnIncomp.flux()
pass
U += rAU * ref.fvc.reconstruct((phi() - phiU) / rAUf) # mixed calculations
U.correctBoundaryConditions()
p << ((p_rgh() + gh * (alpha1() * rho10 + alpha2 * rho20)) /
(1.0 - gh * (alpha1() * psi1 + alpha2 * psi2))).ext_max(pMin) #
rho1 << rho10 + psi1 * p
rho2 << rho20 + psi2 * p
ref.ext_Info() << "max(U) " << U.mag().ext_max().value() << ref.nl
ref.ext_Info() << "min(p_rgh) " << p_rgh.ext_min().value() << ref.nl
pass
def fun_UEqn( U, phi, turbulence, p, sources ): # Solve the Momentum equation UEqn = man.fvm.div( phi, U ) + man( turbulence.divDevReff( U ), man.Deps( turbulence, U ) ) == man( sources( U ), man.Deps( U ) ) UEqn.relax() sources.constrain( UEqn ) ref.solve( UEqn == -man.fvc.grad( p ) ) return UEqn
def fun_Ueqn(pimple, mesh, rho, U, phi, turbulence, ghf, p_rgh):
# Solve the Momentum equation
UEqn = man.fvm.ddt(rho, U) + man.fvm.div(phi, U) + man.fvVectorMatrix(
turbulence.divDevRhoReff(U()), man.Deps(turbulence, U))
UEqn.relax()
if pimple.momentumPredictor():
ref.solve(UEqn == man.fvc.reconstruct(
(-ghf * man.fvc.snGrad(rho) - man.fvc.snGrad(p_rgh)) *
man.surfaceScalarField(mesh.magSf(), man.Deps(mesh))))
return UEqn
def fun_UrelEqn( Urel, phi, turbulence, p, sources, SRF ):
# Solve the Momentum equation
UrelEqn = man.fvVectorMatrix( ref.fvm.div( phi, Urel ) + turbulence.divDevReff( Urel ) + SRF.Su(), man.Deps( turbulence, Urel, phi, SRF ) ) \
== man( sources( Urel ), man.Deps( Urel ) )
UrelEqn.relax()
sources.constrain( UrelEqn )
ref.solve( UrelEqn == -man.fvc.grad( p ) )
return UrelEqn
def fun_UrelEqn(Urel, phi, turbulence, p, sources, SRF):
# Solve the Momentum equation
UrelEqn = man.fvVectorMatrix( ref.fvm.div( phi, Urel ) + turbulence.divDevReff( Urel ) + SRF.Su(), man.Deps( turbulence, Urel, phi, SRF ) ) \
== man( sources( Urel ), man.Deps( Urel ) )
UrelEqn.relax()
sources.constrain(UrelEqn)
ref.solve(UrelEqn == -man.fvc.grad(p))
return UrelEqn
def fun_UEqn( rho, U, phi, ghf, p_rgh, turb, mesh, momentumPredictor, finalIter ) :
# Solve the Momentum equation
UEqn = man.fvm.ddt( rho, U ) + man.fvm.div( phi, U ) + man.fvVectorMatrix( turb.divDevRhoReff( U ), man.Deps( turb, U ) )
UEqn.relax()
if momentumPredictor :
ref.solve( UEqn() == ref.fvc.reconstruct( ( -ghf * ref.fvc.snGrad( rho ) - ref.fvc.snGrad( p_rgh ) ) * mesh.magSf() ),
mesh.solver( U.select( finalIter ) ) )
pass
return UEqn
def fun_UEqn(U, phi, turbulence, p, sources):
# Solve the Momentum equation
UEqn = man.fvm.div(phi, U) + man(turbulence.divDevReff(U),
man.Deps(turbulence, U)) == man(
sources(U), man.Deps(U))
UEqn.relax()
sources.constrain(UEqn)
ref.solve(UEqn == -man.fvc.grad(p))
return UEqn
def fun_UEqn( rho, U, K, phi, ghf, p_rgh, turb, mesh, momentumPredictor, finalIter ):
# Solve the Momentum equation
UEqn = man.fvm.ddt( rho, U ) + man.fvm.div( phi, U ) + man.fvVectorMatrix( turb.divDevRhoReff( U ), man.Deps( turb, U ) )
UEqn.relax()
if momentumPredictor :
ref.solve( UEqn() == ref.fvc.reconstruct( ( -ghf * ref.fvc.snGrad( rho ) - ref.fvc.snGrad( p_rgh ) ) * mesh.magSf() ),
mesh.solver( U.select( finalIter ) ) )
K << 0.5 * U.magSqr()
pass
return UEqn
def fun_UEqn( mesh, U, p_rgh, ghf, rho, rhoPhi, turbulence, twoPhaseProperties, pimple ):
muEff = man.surfaceScalarField( ref.word( "muEff" ),
man.surfaceScalarField( twoPhaseProperties.muf(), man.Deps( twoPhaseProperties ) )
+ man.fvc.interpolate( rho * man.volScalarField( turbulence.ext_nut(), man.Deps( turbulence ) ) ) )
UEqn = man.fvm.ddt( rho, U ) + man.fvm.div( rhoPhi, U ) - man.fvm.laplacian( muEff, U ) - ( man.fvc.grad( U ) & man.fvc.grad( muEff ) )
UEqn.relax()
if pimple.momentumPredictor():
ref.solve( UEqn == ref.fvc.reconstruct( ( - ghf * ref.fvc.snGrad( rho ) - ref.fvc.snGrad( p_rgh ) ) * mesh.magSf() ) )
pass
return UEqn
def Ueqn( mesh, pimple, phi, U, p, turbulence, sources ):
UEqn = man.fvm.ddt(U) + man.fvm.div(phi, U) + man.fvVectorMatrix( turbulence.divDevReff( U ), man.Deps( turbulence, U ) ) \
== man.fvVectorMatrix( sources(U), man.Deps( U ) )
UEqn.relax()
sources.constrain( UEqn )
rAU = man.volScalarField( 1.0/UEqn.A(), man.Deps( UEqn ) )
if pimple.momentumPredictor():
ref.solve( UEqn == -man.fvc.grad( p ) )
pass
return UEqn, rAU
def Ueqn( mesh, pimple, phi, U, p, turbulence, sources ):
# 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 = man.fvm.ddt(U) + man.fvm.div(phi, U) + man.fvVectorMatrix( turbulence.divDevReff( U ), man.Deps( turbulence, U ) )
UEqn = man.fvVectorMatrix( turbulence.divDevReff( U ), man.Deps( turbulence, U ) ) + ( man.fvm.ddt(U) + man.fvm.div(phi, U) )
UEqn.relax()
sources.constrain( UEqn )
rAU = man.volScalarField( 1.0/UEqn.A(), man.Deps( UEqn ) )
if pimple.momentumPredictor():
ref.solve( UEqn == -ref.fvc.grad( p ) + sources( U ) )
pass
return UEqn, rAU
def fun_UEqn( mesh, phi, U, p, rAU, turbulence, pimple ):
# 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 = man.fvm.ddt(U) + man.fvm.div(phi, U) + man.fvVectorMatrix( turbulence.divDevReff( U ), man.Deps( turbulence, U ) )
UEqn = man.fvVectorMatrix( turbulence.divDevReff( U ), man.Deps( turbulence, U ) ) + ( man.fvm.ddt(U) + man.fvm.div(phi, U) )
UEqn.relax()
rAU << 1.0 / UEqn.A()
if pimple.momentumPredictor():
ref.solve( UEqn() == -ref.fvc.grad( p ) )
pass
return UEqn
def Ueqn( mesh, pimple, phi, U, p, turbulence ):
UEqn = man.fvm.ddt(U) + man.fvm.div(phi, U) + man.fvVectorMatrix( turbulence.divDevReff( U ), man.Deps( turbulence, U ) )
UEqn.relax()
rAU = man.volScalarField( 1.0/UEqn.A(), man.Deps( UEqn ) )
if pimple.momentumPredictor():
ref.solve( UEqn == -man.fvc.grad( p ) )
pass
else:
U << rAU * ( UEqn.H() - ref.fvc.grad( p ) )
U.correctBoundaryConditions()
pass
return UEqn, rAU
def fun_UEqn(mesh, phi, U, p, rAU, turbulence, pimple):
# 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 = man.fvm.ddt(U) + man.fvm.div(phi, U) + man.fvVectorMatrix( turbulence.divDevReff( U ), man.Deps( turbulence, U ) )
UEqn = man.fvVectorMatrix(turbulence.divDevReff(U), man.Deps(
turbulence, U)) + (man.fvm.ddt(U) + man.fvm.div(phi, U))
UEqn.relax()
rAU << 1.0 / UEqn.A()
if pimple.momentumPredictor():
ref.solve(UEqn() == -ref.fvc.grad(p))
pass
return UEqn
def Ueqn(mesh, pimple, phi, U, p, turbulence, sources):
# 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 = man.fvm.ddt(U) + man.fvm.div(phi, U) + man.fvVectorMatrix( turbulence.divDevReff( U ), man.Deps( turbulence, U ) )
UEqn = man.fvVectorMatrix(turbulence.divDevReff(U), man.Deps(
turbulence, U)) + (man.fvm.ddt(U) + man.fvm.div(phi, U))
UEqn.relax()
sources.constrain(UEqn)
rAU = man.volScalarField(1.0 / UEqn.A(), man.Deps(UEqn))
if pimple.momentumPredictor():
ref.solve(UEqn == -ref.fvc.grad(p) + sources(U))
pass
return UEqn, rAU
def step(self, nCorr=1, nNonOrthCorr=1):
U_ = self.U
p_ = self.p
phi_ = self.phi
runTime_ = self.runTime
mesh_ = U_.mesh()
runTime_.increment()
# Read transport properties
nu = ref.dimensionedScalar(self.transportProperties.lookup(ref.word("nu")))
tmp_UEqn = ( ref.fvm.ddt( U_ ) + ref.fvm.div( phi_, U_ ) - ref.fvm.laplacian( nu, U_ ) )
UEqn = tmp_UEqn()
self.velocityRes = ref.solve( UEqn == -ref.fvc.grad( p_ ) ).initialResidual()
# --- PISO loop
for corr in range(nCorr):
tmp_rUA = 1.0 / UEqn.A()
rUA = tmp_rUA()
U_ << rUA * UEqn.H()
phi_ << ( ref.fvc.interpolate(U_) & mesh_.Sf() )
for nonOrth in range(nNonOrthCorr):
tmp_pEqn = ( ref.fvm.laplacian( rUA, p_ ) == ref.fvc.div( phi_ ) )
pEqn = tmp_pEqn()
pEqn.setReference( self.pRefCell, self.pRefValue )
pressureRes = pEqn.solve().initialResidual()
if nonOrth == 0:
self.pressureRes = pressureRes
if nonOrth == nNonOrthCorr:
phi_ -= pEqn.flux()
# Continuity errors
tmp_contErr = ref.fvc.div( phi_ );
contErr = tmp_contErr()
sumLocalContErr = (
runTime_.deltaT().value()
* contErr.mag().weightedAverage( mesh_.V() ).value()
)
globalContErr = (
runTime_.deltaT().value()
* contErr.weightedAverage( mesh_.V() ).value()
)
print "time step continuity errors : sum local = " + str(sumLocalContErr) + ", global = " + str(globalContErr)
# Correct velocity
U_-= rUA * ref.fvc.grad( p_ )
U_.correctBoundaryConditions()
def fun_UEqn( mesh, phi, U, p, turbulence, pZones, nUCorr, pressureImplicitPorosity ):
# Construct the Momentum equation
# 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.div( phi, U ) + turbulence.divDevReff( U )
UEqn = man.fvVectorMatrix( turbulence.divDevReff( U ), man.Deps( turbulence, U ) ) + man.fvm.div( phi, U )
UEqn.relax()
# Include the porous media resistance and solve the momentum equation
# either implicit in the tensorial resistance or transport using by
# including the spherical part of the resistance in the momentum diagonal
trAU = None
trTU = None
if pressureImplicitPorosity :
tTU = man.volTensorField( ref.tensor( ref.I ) * UEqn.A(), man.Deps( UEqn ) )
pZones.addResistance( UEqn, tTU )
trTU = man.volTensorField( tTU.inv(), man.Deps( tTU ) )
trTU.rename( ref.word( "rAU" ) )
for UCorr in range ( nUCorr ):
U << ( trTU() & ( UEqn.H() - ref.fvc.grad( p ) ) ) # mixed calculations
pass
U.correctBoundaryConditions()
pass
else:
pZones.addResistance( UEqn )
ref.solve( UEqn == -man.fvc.grad( p ) )
trAU = man.volScalarField( 1.0 / UEqn.A(), man.Deps( UEqn ) )
trAU.rename( ref.word( "rAU" ) )
pass
return UEqn, trTU, trAU
def Ueqn(mesh, pimple, phi, U, p, turbulence):
UEqn = man.fvm.ddt(U) + man.fvm.div(phi, U) + man.fvVectorMatrix(
turbulence.divDevReff(U), man.Deps(turbulence, U))
UEqn.relax()
rAU = man.volScalarField(1.0 / UEqn.A(), man.Deps(UEqn))
if pimple.momentumPredictor():
ref.solve(UEqn == -man.fvc.grad(p))
pass
else:
U << rAU * (UEqn.H() - ref.fvc.grad(p))
U.correctBoundaryConditions()
pass
return UEqn, rAU
def _UrelEqn( mesh, pimple, phi, Urel, p, turbulence, SRF, sources ):
# Relative 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++
# UrelEqn = man.fvVectorMatrix( ref.fvm.ddt( Urel ) + ref.fvm.div( phi, Urel ) + turbulence.divDevReff( Urel ) + SRF.Su(), \
# man.Deps( phi, Urel, turbulence, SRF ) );
UrelEqn = man.fvVectorMatrix( turbulence.divDevReff( Urel ) + ref.fvm.div( phi, Urel ) + ref.fvm.ddt( Urel ) + SRF.Su(), \
man.Deps( phi, Urel, turbulence, SRF ) );
UrelEqn.relax()
sources.constrain( UrelEqn )
ref.solve( UrelEqn == -ref.fvc.grad( p ) + sources( Urel ) )
return UrelEqn
def fun_pEqn( runTime, mesh, pimple, UEqn, p, p_rgh, phi, U, rho, rho1, rho2, rho10, rho20, gh, ghf, dgdt, pMin, \
psi1, psi2, alpha1, alpha2, interface ):
rAU = 1.0/UEqn.A()
rAUf = ref.fvc.interpolate( rAU )
p_rghEqnComp = None
if pimple.transonic():
p_rghEqnComp = ref.fvm.ddt( p_rgh ) + ref.fvm.div( phi, p_rgh ) - ref.fvm.Sp( ref.fvc.div( phi ), p_rgh )
pass
else:
p_rghEqnComp = ref.fvm.ddt( p_rgh ) + ref.fvc.div( phi, p_rgh ) - ref.fvc.Sp( ref.fvc.div( phi ), p_rgh )
pass
U << rAU * UEqn.H()
phiU = ref.surfaceScalarField( ref.word( "phiU" ),
( ref.fvc.interpolate( U ) & mesh.Sf() ) + ref.fvc.ddtPhiCorr( rAU, rho, U, phi ) )
phi << (phiU + ( ref.fvc.interpolate( interface.sigmaK() ) * ref.fvc.snGrad( alpha1 ) - ghf * ref.fvc.snGrad( rho ) ) * rAUf * mesh.magSf() )
while (pimple.correctNonOrthogonal()):
p_rghEqnIncomp = ref.fvc.div( phi ) - ref.fvm.laplacian( rAUf, p_rgh )
ref.solve( ( alpha1.ext_max( 0.0 ) * ( psi1 / rho1 ) + alpha2.ext_max( 0.0 ) * ( psi2 / rho2 ) ) *p_rghEqnComp() + p_rghEqnIncomp, ##
mesh.solver( p_rgh.select( pimple.finalInnerIter() ) ) )
if pimple.finalNonOrthogonalIter():
dgdt << ( alpha2.pos() * ( psi2 / rho2 ) - alpha1.pos() * ( psi1 / rho1 ) ) * ( p_rghEqnComp & p_rgh )
phi += p_rghEqnIncomp.flux()
pass
U += rAU * ref.fvc.reconstruct( ( phi() - phiU ) / rAUf ) # mixed calculations
U.correctBoundaryConditions()
p << ( ( p_rgh() + gh * ( alpha1() * rho10 + alpha2 * rho20 ) ) /( 1.0 - gh * ( alpha1() * psi1 + alpha2 * psi2 ) ) ).ext_max( pMin ) #
rho1 << rho10 + psi1 * p
rho2 << rho20 + psi2 * p
ref.ext_Info() << "max(U) " << U.mag().ext_max().value() << ref.nl
ref.ext_Info() << "min(p_rgh) " << p_rgh.ext_min().value() << ref.nl
pass
def fun_UEqn(mesh, alpha1, U, p, p_rgh, ghf, rho, rhoPhi, turbulence, g,
twoPhaseProperties, interface, pimple):
muEff = ref.surfaceScalarField(
ref.word("muEff"),
twoPhaseProperties.muf() +
ref.fvc.interpolate(rho * turbulence.ext_nut()))
UEqn = ref.fvm.ddt(rho, U) + ref.fvm.div(rhoPhi, U) - ref.fvm.laplacian(
muEff, U) - (ref.fvc.grad(U) & ref.fvc.grad(muEff))
UEqn.relax()
if pimple.momentumPredictor():
ref.solve( UEqn == \
ref.fvc.reconstruct( ( ref.fvc.interpolate( interface.sigmaK() ) * ref.fvc.snGrad( alpha1 ) - ghf * ref.fvc.snGrad( rho ) \
- ref.fvc.snGrad( p_rgh ) ) * mesh.magSf() ) )
pass
return UEqn
def fun_Ueqn( pimple, rho, p, U, phi, turbulence, mrfZones, pZones ):
# 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 = man.fvm.ddt( rho, U ) + man.fvm.div( phi, U ) + man.fvVectorMatrix( turbulence.divDevRhoReff( U ), man.Deps( turbulence, U ) )
UEqn = man.fvVectorMatrix( turbulence.divDevRhoReff( U ), man.Deps( turbulence, U ) ) + ( man.fvm.div( phi, U ) + man.fvm.ddt( rho, U ) )
UEqn.relax()
mrfZones.addCoriolis( rho, UEqn )
pZones.addResistance( UEqn )
rAU = 1.0 / UEqn.A()
if pimple.momentumPredictor():
ref.solve( UEqn == -man.fvc.grad( p ) )
pass
return UEqn
def fun_Ueqn(pimple, mesh, rho, U, phi, turbulence, ghf, p_rgh):
# Solve the Momentum equation
UEqn = (
man.fvm.ddt(rho, U)
+ man.fvm.div(phi, U)
+ man.fvVectorMatrix(turbulence.divDevRhoReff(U()), man.Deps(turbulence, U))
)
UEqn.relax()
if pimple.momentumPredictor():
ref.solve(
UEqn
== man.fvc.reconstruct(
(-ghf * man.fvc.snGrad(rho) - man.fvc.snGrad(p_rgh))
* man.surfaceScalarField(mesh.magSf(), man.Deps(mesh))
)
)
return UEqn
def fun_UEqn( mesh, phi, U, p, turbulence, pZones, nUCorr, pressureImplicitPorosity, sources ):
# Construct the Momentum equation
UEqn = man.fvm.div( phi, U ) + man.fvVectorMatrix( turbulence.divDevReff( U ), man.Deps( turbulence, U ) ) == man( sources( U ), man.Deps( U ) )
UEqn.relax()
sources.constrain( UEqn )
# Include the porous media resistance and solve the momentum equation
# either implicit in the tensorial resistance or transport using by
# including the spherical part of the resistance in the momentum diagonal
trAU = None
trTU = None
if pressureImplicitPorosity :
tTU = man.volTensorField( ref.tensor( ref.I ) * UEqn.A(), man.Deps( UEqn ) )
pZones.addResistance( UEqn, tTU )
trTU = man.volTensorField( tTU.inv(), man.Deps( tTU ) )
trTU.rename( ref.word( "rAU" ) )
for UCorr in range ( nUCorr ):
U << ( trTU() & ( UEqn.H() - ref.fvc.grad( p ) ) ) # mixed calculations
pass
U.correctBoundaryConditions()
pass
else:
pZones.addResistance( UEqn )
ref.solve( UEqn == -man.fvc.grad( p ) )
trAU = man.volScalarField( 1.0 / UEqn.A(), man.Deps( UEqn ) )
trAU.rename( ref.word( "rAU" ) )
pass
return UEqn, trTU, trAU
def fun_Ueqn( pimple, rho, p, U, phi, turbulence ):
# 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 = man.fvm.ddt( rho, U ) + man.fvm.div( phi, U ) + man.fvVectorMatrix( turbulence.divDevRhoReff( U ), man.Deps( turbulence, U ) )
UEqn = man.fvVectorMatrix( turbulence.divDevRhoReff( U ), man.Deps( turbulence, U ) ) + ( man.fvm.div( phi, U ) + man.fvm.ddt( rho, U ) )
UEqn.relax()
rAU = 1.0 / UEqn.A()
if pimple.momentumPredictor():
ref.solve( UEqn == -man.fvc.grad( p ) )
pass
else:
U << rAU * ( UEqn.H() - ref.fvc.grad( p ) )
U.correctBoundaryConditions()
pass
return UEqn, rAU
def fun_Ueqn(pimple, rho, p, U, phi, turbulence, mrfZones, pZones):
# 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 = man.fvm.ddt( rho, U ) + man.fvm.div( phi, U ) + man.fvVectorMatrix( turbulence.divDevRhoReff( U ), man.Deps( turbulence, U ) )
UEqn = man.fvVectorMatrix(
turbulence.divDevRhoReff(U), man.Deps(
turbulence, U)) + (man.fvm.div(phi, U) + man.fvm.ddt(rho, U))
UEqn.relax()
mrfZones.addCoriolis(rho, UEqn)
pZones.addResistance(UEqn)
rAU = 1.0 / UEqn.A()
if pimple.momentumPredictor():
ref.solve(UEqn == -man.fvc.grad(p))
pass
return UEqn
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 fun_Ueqn(rho, U, phi, turbulence, p):
UEqn = man.fvm.ddt(rho, U) + man.fvm.div(phi, U) + man(
turbulence.divDevRhoReff(U()), man.Deps(turbulence, U))
ref.solve(UEqn == -man.fvc.grad(p))
return UEqn
def main_standalone(argc, argv):
args = ref.setRootCase(argc, argv)
runTime = man.createTime(args)
mesh = man.createMeshNoClear(runTime)
transportProperties, nu = readTransportProperties(runTime, mesh)
p, U, phi = _createFields(runTime, mesh)
turbulenceProperties, force, K, forceGen = readTurbulenceProperties(
runTime, mesh, U)
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)
force.internalField() << (ref.ReImSum(
ref.fft.reverseTransform(
K / (K.mag() + 1.0e-6) ^ forceGen.newField(), K.nn())))
globalProperties(runTime, U, nu, force)
UEqn = ref.fvm.ddt(U) + ref.fvm.div(phi, U) - ref.fvm.laplacian(
nu, U) == force
ref.solve(UEqn == -man.fvc.grad(p))
# --- PISO loop
for corr in range(1):
rUA = 1.0 / UEqn.A()
U << rUA * UEqn.H()
phi << (ref.fvc.interpolate(U) & mesh.Sf()) + ref.fvc.ddtPhiCorr(
rUA, U, phi)
pEqn = ref.fvm.laplacian(rUA, p) == ref.fvc.div(phi)
pEqn.solve()
phi -= pEqn.flux()
cumulativeContErr = ref.ContinuityErrs(phi, runTime, mesh,
cumulativeContErr)
U -= rUA * ref.fvc.grad(p)
U.correctBoundaryConditions()
pass
runTime.write()
if runTime.outputTime():
ref.calcEk(U, K).ext_write(
ref.fileName(runTime.path()) / ref.fileName("graphs") /
ref.fileName(runTime.timeName()), ref.word("Ek"),
runTime.graphFormat())
pass
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.createMeshNoClear( runTime )
transportProperties, nu = readTransportProperties( runTime, mesh )
p, U, phi = _createFields( runTime, mesh )
turbulenceProperties, force, K, forceGen = readTurbulenceProperties( runTime, mesh, U )
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 )
force.internalField() << ( ref.ReImSum( ref.fft.reverseTransform( K / ( K.mag() + 1.0e-6 ) ^ forceGen.newField(), K.nn() ) ) )
globalProperties( runTime, U, nu, force )
UEqn = ref.fvm.ddt( U ) + ref.fvm.div( phi, U ) - ref.fvm.laplacian( nu, U ) == force
ref.solve( UEqn == - man.fvc.grad( p ) )
# --- PISO loop
for corr in range( 1 ):
rUA = 1.0 / UEqn.A()
U << rUA * UEqn.H()
phi << ( ref.fvc.interpolate( U ) & mesh.Sf() ) + ref.fvc.ddtPhiCorr( rUA, U, phi )
pEqn = ref.fvm.laplacian( rUA, p ) == ref.fvc.div( phi )
pEqn.solve()
phi -= pEqn.flux()
cumulativeContErr = ref.ContinuityErrs( phi, runTime, mesh, cumulativeContErr )
U -= rUA * ref.fvc.grad( p )
U.correctBoundaryConditions()
pass
runTime.write()
if runTime.outputTime():
ref.calcEk( U, K ).ext_write( ref.fileName( runTime.path() )/ref.fileName("graphs")/ref.fileName( runTime.timeName() ),
ref.word( "Ek" ),
runTime.graphFormat() )
pass
ref.ext_Info() << "ExecutionTime = " << runTime.elapsedCpuTime() << " s" \
<< " ClockTime = " << runTime.elapsedClockTime() << " s" << ref.nl << ref.nl
pass
ref.ext_Info() << "End\n" << ref.nl
import os
return os.EX_OK
def main_standalone(argc, argv):
args = ref.setRootCase(argc, argv)
runTime = man.createTime(args)
mesh = man.createMesh(runTime)
gravitationalProperties, g, rotating, Omega, magg, gHat = readGravitationalAcceleration(
runTime, mesh)
h, h0, U, hU, hTotal, phi, F = _createFields(runTime, mesh, Omega, gHat)
pimple = man.pimpleControl(mesh)
ref.ext_Info() << "\nStarting time loop\n" << ref.nl
while runTime.loop():
ref.ext_Info() << "\n Time = " << runTime.timeName(
) << ref.nl << ref.nl
CourantNo(runTime, mesh, h, phi, magg)
pimple.start()
while pimple.loop():
phiv = ref.surfaceScalarField(
ref.word("phiv"),
phi() / ref.fvc.interpolate(h)) # mixed calculations
hUEqn = ref.fvm.ddt(hU) + ref.fvm.div(phiv, hU)
hUEqn.relax()
if pimple.momentumPredictor():
if rotating:
ref.solve(hUEqn + (F ^ hU) == -magg * h *
ref.fvc.grad(h + h0))
pass
else:
ref.solve(hUEqn == -magg * h * ref.fvc.grad(h + h0))
pass
# Constrain the momentum to be in the geometry if 3D geometry
if mesh.nGeometricD() == 3:
hU -= (gHat & hU) * gHat
hU.correctBoundaryConditions()
pass
for corr in range(pimple.nCorr()):
hf = ref.fvc.interpolate(h)
rUA = 1.0 / hUEqn.A()
ghrUAf = magg * ref.fvc.interpolate(h * rUA)
phih0 = ghrUAf * mesh.magSf() * ref.fvc.snGrad(h0)
if rotating:
hU << rUA * (hUEqn.H() - (F ^ hU))
pass
else:
hU << rUA * hUEqn.H()
pass
phi << (ref.fvc.interpolate(hU) & mesh.Sf()
) + ref.fvc.ddtPhiCorr(rUA, h, hU, phi) - phih0
for nonOrth in range(pimple.nNonOrthCorr() + 1):
hEqn = ref.fvm.ddt(h) + ref.fvc.div(
phi) - ref.fvm.laplacian(ghrUAf, h)
hEqn.solve(
mesh.solver(
h.select(pimple.finalInnerIter(corr, nonOrth))))
if nonOrth == pimple.nNonOrthCorr():
phi += hEqn.flux()
pass
hU -= rUA * h * magg * ref.fvc.grad(h + h0)
#Constrain the momentum to be in the geometry if 3D geometry
if mesh.nGeometricD() == 3:
hU -= (gHat & hU) * gHat
pass
hU.correctBoundaryConditions()
pass
pimple.increment()
pass
U == hU / h
hTotal == h + h0
runTime.write()
ref.ext_Info() << "ExecutionTime = " << runTime.elapsedCpuTime() << " s" << \
" ClockTime = " << runTime.elapsedClockTime() << " s" << ref.nl << ref.nl
pass
ref.ext_Info() << "End\n" << ref.nl
import os
return os.EX_OK
def step(self):
if self.runTime_.end():
ref.ext_Info() << "Reached end time. Exiting" << ref.nl
return
self.runTime_.increment()
# Read transport properties
nu = ref.dimensionedScalar(self.transportProperties_.lookup(ref.word("nu")))
if self.mesh_.nInternalFaces():
SfUfbyDelta = self.mesh_.deltaCoeffs() * self.phi_.mag()
CoNum = (SfUfbyDelta / self.mesh_.magSf()).ext_max().value() * self.runTime_.deltaT().value()
meanCoNum = (SfUfbyDelta.sum() / self.mesh_.magSf().sum()).value() * self.runTime_.deltaT().value()
ref.ext_Info() << "Courant Number mean: " << meanCoNum << " max: " << CoNum << ref.nl
pass
# Read controls
piso = self.mesh_.solutionDict().subDict(ref.word("PISO"))
nCorr = ref.readInt(piso.lookup(ref.word("nCorrectors")))
nNonOrthCorr = 0
if piso.found(ref.word("nNonOrthogonalCorrectors")):
nNonOrthCorr = ref.readInt(piso.lookup(ref.word("nNonOrthogonalCorrectors")))
pass
UEqn = ref.fvm.ddt(self.U_) + ref.fvm.div(self.phi_, self.U_) - ref.fvm.laplacian(nu, self.U_)
self.velocityRes_ = ref.solve(UEqn == -ref.fvc.grad(self.p_)).initialResidual()
# --- PISO loop
for corr in range(nCorr):
rUA = 1.0 / UEqn.A()
self.U_ << rUA * UEqn.H()
self.phi_ << (ref.fvc.interpolate(self.U_) & self.mesh_.Sf()) + ref.fvc.ddtPhiCorr(rUA, self.U_, self.phi_)
# adjustPhi(phi_, U_, p_);
for nonOrth in range(nNonOrthCorr + 1):
pEqn = ref.fvm.laplacian(rUA, self.p_) == ref.fvc.div(self.phi_)
pEqn.setReference(self.pRefCell_, self.pRefValue_)
self.pressureRes_ = pEqn.solve().initialResidual()
if nonOrth == nNonOrthCorr:
self.phi_ -= pEqn.flux()
pass
pass
# Continuity errors
contErr = ref.fvc.div(self.phi_)
sumLocalContErr = self.runTime_.deltaT().value() * contErr.mag().weightedAverage(self.mesh_.V()).value()
globalContErr = self.runTime_.deltaT().value() * contErr.weightedAverage(self.mesh_.V()).value()
ref.ext_Info() << "time step continuity errors : sum local = " << sumLocalContErr << ", global = " << globalContErr << ref.nl
# Correct velocity
self.U_ -= rUA * ref.fvc.grad(self.p_)
self.U_.correctBoundaryConditions()
pass
def main_standalone(argc, argv):
args = ref.setRootCase(argc, argv)
runTime = man.createTime(args)
mesh = man.createMesh(runTime)
thermodynamicProperties, rho0, p0, psi, rhoO = readThermodynamicProperties(
runTime, mesh)
transportProperties, mu = readTransportProperties(runTime, mesh)
p, U, rho, phi = createFields(runTime, mesh, rhoO, psi)
cumulativeContErr = ref.initContinuityErrs()
#// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
ref.ext_Info() << "\nStarting time loop\n" << ref.nl
while runTime.loop():
ref.ext_Info() << "Time = " << runTime.timeName() << ref.nl << ref.nl
piso, nCorr, nNonOrthCorr, momentumPredictor, transonic, nOuterCorr = ref.readPISOControls(
mesh)
CoNum, meanCoNum = ref.compressibleCourantNo(mesh, phi, rho, runTime)
ref.rhoEqn(rho, phi)
UEqn = man.fvm.ddt(rho, U) + man.fvm.div(phi, U) - man.fvm.laplacian(
mu, U)
ref.solve(UEqn == -man.fvc.grad(p))
# --- PISO loop
for corr in range(nCorr):
rAU = 1.0 / UEqn.A()
U << rAU * UEqn.H()
phid = ref.surfaceScalarField(
ref.word("phid"),
psi * ((ref.fvc.interpolate(U) & mesh.Sf()) +
ref.fvc.ddtPhiCorr(rAU, rho(), U(), phi())))
phi << (rhoO / psi) * phid
pEqn = ref.fvm.ddt(psi, p()) + ref.fvc.div(phi()) + ref.fvm.div(
phid, p()) - ref.fvm.laplacian(rho() * rAU, p())
pEqn.solve()
phi += pEqn.flux()
cumulativeContErr = compressibleContinuityErrs(
rho, phi, p, rho0, p0, psi, cumulativeContErr)
U -= rAU * ref.fvc.grad(p)
U.correctBoundaryConditions()
pass
rho << rhoO + psi * p
runTime.write()
ref.ext_Info()<< "ExecutionTime = " << runTime.elapsedCpuTime() << " s" \
<< " ClockTime = " << runTime.elapsedClockTime() << " s" \
<< ref.nl << ref.nl
pass
ref.ext_Info() << "End\n" << ref.nl
import os
return os.EX_OK
def 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)
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 )
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)
gravitationalProperties, g, rotating, Omega, magg, gHat = readGravitationalAcceleration(runTime, mesh)
h, h0, U, hU, hTotal, phi, F = _createFields(runTime, mesh, Omega, gHat)
pimple = man.pimpleControl(mesh)
ref.ext_Info() << "\nStarting time loop\n" << ref.nl
while runTime.loop():
ref.ext_Info() << "\n Time = " << runTime.timeName() << ref.nl << ref.nl
CourantNo(runTime, mesh, h, phi, magg)
pimple.start()
while pimple.loop():
phiv = ref.surfaceScalarField(ref.word("phiv"), phi() / ref.fvc.interpolate(h)) # mixed calculations
hUEqn = ref.fvm.ddt(hU) + ref.fvm.div(phiv, hU)
hUEqn.relax()
if pimple.momentumPredictor():
if rotating:
ref.solve(hUEqn + (F ^ hU) == -magg * h * ref.fvc.grad(h + h0))
pass
else:
ref.solve(hUEqn == -magg * h * ref.fvc.grad(h + h0))
pass
# Constrain the momentum to be in the geometry if 3D geometry
if mesh.nGeometricD() == 3:
hU -= (gHat & hU) * gHat
hU.correctBoundaryConditions()
pass
for corr in range(pimple.nCorr()):
hf = ref.fvc.interpolate(h)
rUA = 1.0 / hUEqn.A()
ghrUAf = magg * ref.fvc.interpolate(h * rUA)
phih0 = ghrUAf * mesh.magSf() * ref.fvc.snGrad(h0)
if rotating:
hU << rUA * (hUEqn.H() - (F ^ hU))
pass
else:
hU << rUA * hUEqn.H()
pass
phi << (ref.fvc.interpolate(hU) & mesh.Sf()) + ref.fvc.ddtPhiCorr(rUA, h, hU, phi) - phih0
for nonOrth in range(pimple.nNonOrthCorr() + 1):
hEqn = ref.fvm.ddt(h) + ref.fvc.div(phi) - ref.fvm.laplacian(ghrUAf, h)
hEqn.solve(mesh.solver(h.select(pimple.finalInnerIter(corr, nonOrth))))
if nonOrth == pimple.nNonOrthCorr():
phi += hEqn.flux()
pass
hU -= rUA * h * magg * ref.fvc.grad(h + h0)
# Constrain the momentum to be in the geometry if 3D geometry
if mesh.nGeometricD() == 3:
hU -= (gHat & hU) * gHat
pass
hU.correctBoundaryConditions()
pass
pimple.increment()
pass
U == hU / h
hTotal == h + h0
runTime.write()
ref.ext_Info() << "ExecutionTime = " << runTime.elapsedCpuTime() << " s" << " ClockTime = " << runTime.elapsedClockTime() << " s" << ref.nl << ref.nl
pass
ref.ext_Info() << "End\n" << ref.nl
import os
return os.EX_OK
def main_standalone(argc, argv):
args = ref.setRootCase(argc, argv)
runTime = man.createTime(args)
mesh = man.createMesh(runTime)
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 )
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
