def CourantNo(runTime, mesh, h, phi, magg):
CoNum = 0.0
meanCoNum = 0.0
waveCoNum = 0.0
if mesh.nInternalFaces():
from Foam import fvc
SfUfbyDelta = mesh.deltaCoeffs() * phi.mag() / fvc.interpolate(h)
CoNum = (SfUfbyDelta /
mesh.magSf()).ext_max().value() * runTime.deltaT().value()
meanCoNum = (SfUfbyDelta.sum() /
mesh.magSf().sum()).value() * runTime.deltaT().value()
# Gravity wave Courant number
waveCoNum = 0.5 * (mesh.deltaCoeffs() * fvc.interpolate(h).sqrt(
)).ext_max().value() * magg.sqrt().value() * runTime.deltaT().value()
from Foam.OpenFOAM import ext_Info, nl
ext_Info(
) << "Courant number mean: " << meanCoNum << " max: " << CoNum << nl
ext_Info() << "Gravity wave Courant number max: " << waveCoNum << nl
return CoNum, meanCoNum, waveCoNum
def _UEqn(mesh, alpha1, U, p, rho, rhoPhi, turbulence, g, twoPhaseProperties, interface, momentumPredictor):
from Foam.OpenFOAM import word
from Foam.finiteVolume import surfaceScalarField
from Foam import fvc
muEff = surfaceScalarField(word("muEff"), twoPhaseProperties.muf() + fvc.interpolate(rho * turbulence.ext_nut()))
from Foam import fvm
UEqn = fvm.ddt(rho, U) + fvm.div(rhoPhi, U) - fvm.laplacian(muEff, U) - (fvc.grad(U) & fvc.grad(muEff))
UEqn.relax()
if momentumPredictor:
from Foam.finiteVolume import solve
solve(
UEqn
== fvc.reconstruct(
fvc.interpolate(rho) * (g & mesh.Sf())
+ (fvc.interpolate(interface.sigmaK()) * fvc.snGrad(alpha1) - fvc.snGrad(p)) * mesh.magSf()
)
)
pass
return UEqn
def _pEqn( rho, thermo, UEqn, nNonOrthCorr, psi, U, mesh, phi, p, cumulativeContErr ):
from Foam.finiteVolume import volScalarField
rUA = 1.0/UEqn.A()
U.ext_assign( rUA*UEqn.H() )
from Foam import fvc
from Foam.finiteVolume import surfaceScalarField
from Foam.OpenFOAM import word
phid = surfaceScalarField( word( "phid" ),
fvc.interpolate( thermo.psi() ) * ( (fvc.interpolate( U ) & mesh.Sf() ) + fvc.ddtPhiCorr( rUA, rho, U, phi ) ) )
for nonOrth in range( nNonOrthCorr + 1 ) :
from Foam import fvm
pEqn = ( fvm.ddt(psi, p) + fvm.div(phid, word( "div(phid,p)" ) ) - fvm.laplacian(rho*rUA, p) )
pEqn.solve()
if (nonOrth == nNonOrthCorr) :
phi.ext_assign( pEqn.flux() )
pass
pass
from Foam.finiteVolume.cfdTools.compressible import rhoEqn
rhoEqn( rho, phi )
from Foam.finiteVolume.cfdTools.compressible import compressibleContinuityErrs
cumulativeContErr = compressibleContinuityErrs( rho, thermo, cumulativeContErr )
U.ext_assign( U - rUA * fvc.grad(p) )
U.correctBoundaryConditions()
return cumulativeContErr
def fun_pEqn( runTime, thermo, UEqn, U, phi, rho, gh, pd, p, initialMass, mesh, pRef, nNonOrthCorr, \
pdRefCell, pdRefValue, eqnResidual, maxResidual, cumulativeContErr ):
rUA = 1.0/UEqn.A()
U.ext_assign( rUA * UEqn().H() )
UEqn.clear()
from Foam import fvc
phi.ext_assign( fvc.interpolate( rho )*(fvc.interpolate(U) & mesh.Sf()) )
from Foam.finiteVolume import adjustPhi
closedVolume = adjustPhi(phi, U, p)
phi.ext_assign( phi - fvc.interpolate( rho *gh * rUA ) * fvc.snGrad( rho ) * mesh.magSf() )
from Foam import fvm
for nonOrth in range( nNonOrthCorr + 1):
pdEqn = ( fvm.laplacian( rho * rUA, pd ) == fvc.div(phi) )
pdEqn.setReference(pdRefCell, pdRefValue)
# retain the residual from the first iteration
if nonOrth == 0:
eqnResidual = pdEqn.solve().initialResidual()
maxResidual = max(eqnResidual, maxResidual)
pass
else:
pdEqn.solve()
pass
if nonOrth == nNonOrthCorr:
phi.ext_assign( phi - pdEqn.flux() )
pass
pass
from Foam.finiteVolume.cfdTools.general.include import ContinuityErrs
cumulativeContErr = ContinuityErrs( phi, runTime, mesh, cumulativeContErr )
# Explicitly relax pressure for momentum corrector
pd.relax()
p.ext_assign( pd + rho * gh + pRef )
U.ext_assign( U- rUA * ( fvc.grad( pd ) + fvc.grad( rho ) * gh ) )
U.correctBoundaryConditions()
# For closed-volume cases adjust the pressure and density levels
# to obey overall mass continuity
if closedVolume:
p.ext_assign( p + ( initialMass - fvc.domainIntegrate( thermo.psi() * p ) ) / fvc.domainIntegrate( thermo.psi() ) )
rho.ext_assign( thermo.rho() )
rho.relax()
from Foam.OpenFOAM import ext_Info, nl
ext_Info()<< "rho max/min : " << rho.ext_max().value() << " " << rho.ext_min().value() << nl
return eqnResidual, maxResidual, cumulativeContErr
def fun_pEqn( i, mesh, p, rho, turb, thermo, thermoFluid, K, UEqn, U, phi, psi, DpDt, initialMass, p_rgh, gh, ghf, \
nNonOrthCorr, oCorr, nOuterCorr, corr, nCorr, cumulativeContErr ) :
closedVolume = p_rgh.needReference()
rho.ext_assign( thermo.rho() )
rUA = 1.0 / UEqn.A()
from Foam import fvc
from Foam.OpenFOAM import word
from Foam.finiteVolume import surfaceScalarField
rhorUAf = surfaceScalarField( word( "(rho*(1|A(U)))" ) , fvc.interpolate( rho * rUA ) )
U.ext_assign( rUA * UEqn.H() )
from Foam import fvc
phiU = ( fvc.interpolate( rho ) *
( ( fvc.interpolate( U ) & mesh.Sf() ) +
fvc.ddtPhiCorr( rUA, rho, U, phi ) ) )
phi.ext_assign( phiU - rhorUAf * ghf * fvc.snGrad( rho ) * mesh.magSf() )
from Foam import fvm
for nonOrth in range ( nNonOrthCorr + 1 ):
p_rghEqn = ( fvm.ddt( psi, p_rgh) + fvc.ddt( psi, rho ) * gh + fvc.div( phi ) - fvm.laplacian( rhorUAf, p_rgh ) )
p_rghEqn.solve( mesh.solver( p_rgh.select( ( oCorr == nOuterCorr-1 and corr == ( nCorr-1 ) and nonOrth == nNonOrthCorr ) ) ) )
if nonOrth == nNonOrthCorr :
phi.ext_assign( phi + p_rghEqn.flux() )
pass
pass
# Correct velocity field
U.ext_assign( U + rUA * fvc.reconstruct( ( phi - phiU ) / rhorUAf ) )
U.correctBoundaryConditions()
p.ext_assign( p_rgh + rho * gh )
#Update pressure substantive derivative
DpDt.ext_assign( fvc.DDt( surfaceScalarField( word( "phiU" ), phi / fvc.interpolate( rho ) ), p ) )
# Solve continuity
from Foam.finiteVolume.cfdTools.compressible import rhoEqn
rhoEqn( rho, phi )
# Update continuity errors
cumulativeContErr = compressibleContinuityErrors( i, mesh, rho, thermo, cumulativeContErr )
# For closed-volume cases adjust the pressure and density levels
# to obey overall mass continuity
if closedVolume :
p.ext_assign( p + ( initialMass - fvc.domainIntegrate( psi * p ) ) / fvc.domainIntegrate( psi ) )
rho.ext_assign( thermo.rho() )
p_rgh.ext_assign( p - rho * gh )
pass
#Update thermal conductivity
K.ext_assign( thermoFluid[ i ].Cp() * turb.alphaEff() )
return cumulativeContErr
def _pEqn( runTime, mesh, UEqn, thermo, p, psi, U, rho, phi, DpDt, g, initialMass, totalVolume, corr, nCorr, nNonOrthCorr, cumulativeContErr ):
closedVolume = p.needReference()
rho.ext_assign( thermo.rho() )
# Thermodynamic density needs to be updated by psi*d(p) after the
# pressure solution - done in 2 parts. Part 1:
thermo.rho().ext_assign( thermo.rho() - psi * p )
rUA = 1.0/UEqn.A()
from Foam.OpenFOAM import word
from Foam.finiteVolume import surfaceScalarField
from Foam import fvc
rhorUAf = surfaceScalarField( word( "(rho*(1|A(U)))" ), fvc.interpolate( rho * rUA ) )
U.ext_assign( rUA * UEqn.H() )
phiU = fvc.interpolate( rho ) * ( (fvc.interpolate( U ) & mesh.Sf() ) + fvc.ddtPhiCorr( rUA, rho, U, phi ) )
phi.ext_assign( phiU + rhorUAf * fvc.interpolate( rho ) * (g & mesh.Sf() ) )
for nonOrth in range( nNonOrthCorr+1 ):
from Foam import fvm
from Foam.finiteVolume import correction
pEqn = fvc.ddt( rho ) + psi * correction( fvm.ddt( p ) ) + fvc.div( phi ) - fvm.laplacian( rhorUAf, p )
if corr == nCorr-1 and nonOrth == nNonOrthCorr:
pEqn.solve( mesh.solver( word( str( p.name() ) + "Final" ) ) )
pass
else:
pEqn.solve( mesh.solver( p.name() ) )
pass
if nonOrth == nNonOrthCorr:
phi.ext_assign( phi + pEqn.flux() )
pass
# Second part of thermodynamic density update
thermo.rho().ext_assign( thermo.rho() + psi * p )
U.ext_assign( U + rUA * fvc.reconstruct( ( phi - phiU ) / rhorUAf ) )
U.correctBoundaryConditions()
DpDt.ext_assign( fvc.DDt( surfaceScalarField( word( "phiU" ), phi / fvc.interpolate( rho ) ), p ) )
from Foam.finiteVolume.cfdTools.compressible import rhoEqn
rhoEqn( rho, phi )
from Foam.finiteVolume.cfdTools.compressible import compressibleContinuityErrs
cumulativeContErr = compressibleContinuityErrs( rho, thermo, cumulativeContErr )
# For closed-volume cases adjust the pressure and density levels
# to obey overall mass continuity
if closedVolume:
p.ext_assign( p + ( initialMass - fvc.domainIntegrate( psi * p ) ) / fvc.domainIntegrate( psi ) )
thermo.rho().ext_assign( psi * p )
rho.ext_assign( rho + ( initialMass - fvc.domainIntegrate( rho ) ) / totalVolume )
pass
return cumulativeContErr
def fun_pEqn( runTime, mesh, p, phi, U, UEqn, g, rhok, eqnResidual, maxResidual, nNonOrthCorr, cumulativeContErr, pRefCell, pRefValue ):
from Foam.finiteVolume import volScalarField, surfaceScalarField
from Foam.OpenFOAM import word
from Foam import fvc
rUA = volScalarField( word( "rUA" ), 1.0 / UEqn().A() )
rUAf = surfaceScalarField(word( "(1|A(U))" ), fvc.interpolate( rUA ) )
U.ext_assign( rUA * UEqn().H() )
UEqn.clear()
from Foam import fvc
phi.ext_assign( fvc.interpolate( U ) & mesh.Sf() )
from Foam.finiteVolume import adjustPhi
adjustPhi( phi, U, p )
buoyancyPhi = rUAf * fvc.interpolate( rhok ) * ( g & mesh.Sf() )
phi.ext_assign( phi + buoyancyPhi )
for nonOrth in range( nNonOrthCorr+1 ):
from Foam import fvm, fvc
pEqn = fvm.laplacian(rUAf, p) == fvc.div(phi)
pEqn.setReference( pRefCell, pRefValue )
# retain the residual from the first iteration
if ( nonOrth == 0 ):
eqnResidual = pEqn.solve().initialResidual()
maxResidual = max( eqnResidual, maxResidual )
pass
else:
pEqn.solve()
pass
if ( nonOrth == nNonOrthCorr ):
# Calculate the conservative fluxes
phi.ext_assign( phi - pEqn.flux() )
# Explicitly relax pressure for momentum corrector
p.relax()
# Correct the momentum source with the pressure gradient flux
# calculated from the relaxed pressure
U.ext_assign( U + rUA * fvc.reconstruct( ( buoyancyPhi - pEqn.flux() ) / rUAf ) )
U.correctBoundaryConditions()
pass
pass
from Foam.finiteVolume.cfdTools.incompressible import continuityErrs
cumulativeContErr = continuityErrs( mesh, phi, runTime, cumulativeContErr )
return eqnResidual, maxResidual, cumulativeContErr
def fun_pEqn( mesh, p, rho, psi, p_rgh, U, phi, ghf, gh, DpDt, UEqn, thermo, nNonOrthCorr, corr, nCorr, finalIter, cumulativeContErr ):
rho.ext_assign( thermo.rho() )
# Thermodynamic density needs to be updated by psi*d(p) after the
# pressure solution - done in 2 parts. Part 1:
thermo.rho().ext_assign( thermo.rho() - psi * p_rgh )
rUA = 1.0 / UEqn.A()
from Foam.finiteVolume import surfaceScalarField
from Foam.OpenFOAM import word
from Foam import fvc
rhorUAf = surfaceScalarField( word( "(rho*(1|A(U)))" ), fvc.interpolate( rho * rUA ) )
U.ext_assign( rUA*UEqn.H() )
phi.ext_assign( fvc.interpolate( rho ) * ( ( fvc.interpolate( U ) & mesh.Sf() ) + fvc.ddtPhiCorr( rUA, rho, U, phi ) ) )
buoyancyPhi = -rhorUAf * ghf * fvc.snGrad( rho ) * mesh.magSf()
phi.ext_assign( phi + buoyancyPhi )
from Foam import fvm
from Foam.finiteVolume import correction
for nonOrth in range( nNonOrthCorr +1 ):
p_rghEqn = fvc.ddt( rho ) + psi * correction( fvm.ddt( p_rgh ) ) + fvc.div( phi ) - fvm.laplacian( rhorUAf, p_rgh )
p_rghEqn.solve( mesh.solver( p_rgh.select( ( finalIter and corr == nCorr-1 and nonOrth == nNonOrthCorr ) ) ) )
if nonOrth == nNonOrthCorr:
# Calculate the conservative fluxes
phi.ext_assign( phi + p_rghEqn.flux() )
# Explicitly relax pressure for momentum corrector
p_rgh.relax()
# Correct the momentum source with the pressure gradient flux
# calculated from the relaxed pressure
U.ext_assign( U + rUA * fvc.reconstruct( ( buoyancyPhi + p_rghEqn.flux() ) / rhorUAf ) )
U.correctBoundaryConditions()
pass
p.ext_assign( p_rgh + rho * gh )
# Second part of thermodynamic density update
thermo.rho().ext_assign( thermo.rho() + psi * p_rgh )
DpDt.ext_assign( fvc.DDt( surfaceScalarField( word( "phiU" ), phi / fvc.interpolate( rho ) ), p ) )
from Foam.finiteVolume.cfdTools.compressible import rhoEqn
rhoEqn( rho, phi )
from Foam.finiteVolume.cfdTools.compressible import compressibleContinuityErrs
cumulativeContErr = compressibleContinuityErrs( rho, thermo, cumulativeContErr )
return cumulativeContErr
def _pEqn( runTime, mesh, UEqn, U, p, p_rgh, gh, ghf, phi, alpha1, rho, g, interface, corr, nCorr, nNonOrthCorr, pRefCell, pRefValue, cumulativeContErr ):
rAU = 1.0/UEqn.A()
from Foam import fvc
rAUf = fvc.interpolate( rAU )
U.ext_assign( rAU * UEqn.H() )
from Foam.finiteVolume import surfaceScalarField
from Foam.OpenFOAM import word
phiU = surfaceScalarField( word( "phiU" ), fvc.interpolate( U ) & mesh.Sf() )
if p_rgh.needReference():
fvc.makeRelative( phiU, U )
from Foam.finiteVolume import adjustPhi
adjustPhi( phiU, U, p )
fvc.makeAbsolute( phiU, U )
pass
phi.ext_assign( phiU + ( fvc.interpolate( interface.sigmaK() ) * fvc.snGrad( alpha1 ) - ghf * fvc.snGrad( rho ) )*rAUf*mesh.magSf() )
from Foam import fvm
for nonOrth in range( nNonOrthCorr + 1 ):
p_rghEqn = fvm.laplacian( rAUf, p_rgh ) == fvc.div( phi )
p_rghEqn.setReference( pRefCell, pRefValue )
p_rghEqn.solve( mesh.solver( p_rgh.select(corr == nCorr-1 and nonOrth == nNonOrthCorr) ) )
if nonOrth == nNonOrthCorr:
phi.ext_assign( phi - p_rghEqn.flux() )
pass
pass
U.ext_assign( U + rAU * fvc.reconstruct( ( phi - phiU ) / rAUf ) )
U.correctBoundaryConditions()
from Foam.finiteVolume.cfdTools.incompressible import continuityErrs
cumulativeContErr = continuityErrs( mesh, phi, runTime, cumulativeContErr )
# Make the fluxes relative to the mesh motion
fvc.makeRelative( phi, U )
p == p_rgh + rho * gh
if p_rgh.needReference():
from Foam.OpenFOAM import pRefValue
p.ext_assign( p + dimensionedScalar( word( "p" ),
p.dimensions(),
pRefValue - getRefCellValue(p, pRefCell) ) )
p_rgh.ext_assign( p - rho * gh )
pass
return cumulativeContErr
def alphaEqns( runTime, mesh, rho1, rho2, rhoPhi, phic, dgdt, divU, alpha1, alpha2, phi, interface, nAlphaCorr ):
from Foam.OpenFOAM import word
alphaScheme = word( "div(phi,alpha)" )
alpharScheme = word( "div(phirb,alpha)" )
phir = phic*interface.nHatf()
from Foam.finiteVolume import volScalarField
from Foam.OpenFOAM import IOobject, word, fileName, dimensionedScalar, scalar, ext_Info, nl
for gCorr in range( nAlphaCorr ):
Sp = volScalarField.DimensionedInternalField( IOobject( word( "Sp" ),
fileName( runTime.timeName() ),
mesh ),
mesh,
dimensionedScalar( word( "Sp" ), dgdt.dimensions(), 0.0 ) )
Su = volScalarField.DimensionedInternalField( IOobject( word( "Su" ),
fileName( runTime.timeName() ),
mesh ),
# Divergence term is handled explicitly to be
# consistent with the explicit transport solution
divU * alpha1.ext_min( scalar( 1 ) ) )
for celli in range( dgdt.size() ):
if dgdt[ celli ] > 0.0 and alpha1[ celli ] > 0.0:
Sp[ celli ] -= dgdt[ celli ] * alpha1[ celli ]
Su[ celli ] += dgdt[ celli ] * alpha1[ celli ]
pass
elif dgdt[ celli ] < 0.0 and alpha1[ celli ] < 1.0:
Sp[ celli ] += dgdt[ celli ] * ( 1.0 - alpha1[ celli ] )
pass
pass
from Foam import fvc
phiAlpha1 = fvc.flux( phi, alpha1, alphaScheme ) + fvc.flux( - fvc.flux( -phir, alpha2, alpharScheme ), alpha1, alpharScheme )
from Foam import MULES
from Foam.OpenFOAM import geometricOneField
MULES.explicitSolve( geometricOneField(), alpha1, phi, phiAlpha1, Sp, Su, 1.0, 0.0 )
rho1f = fvc.interpolate( rho1 )
rho2f = fvc.interpolate( rho2 )
rhoPhi.ext_assign( phiAlpha1 * ( rho1f - rho2f ) + phi * rho2f )
alpha2.ext_assign( scalar( 1 ) - alpha1 )
pass
from Foam.OpenFOAM import ext_Info, nl
ext_Info() << "Liquid phase volume fraction = " << alpha1.weightedAverage( mesh.V() ).value() \
<< " Min(alpha1) = " << alpha1.ext_min().value() << " Min(alpha2) = " << alpha2.ext_min().value() << nl
pass
def fun_pEqn( thermo, g, rho, UEqn, p, U, psi, phi, initialMass, runTime, mesh, nNonOrthCorr, pRefCell, eqnResidual, maxResidual, cumulativeContErr ):
rho.ext_assign( thermo.rho() )
rUA = 1.0/UEqn.A()
from Foam.OpenFOAM import word
from Foam import fvc,fvm
from Foam.finiteVolume import surfaceScalarField
rhorUAf = surfaceScalarField(word( "(rho*(1|A(U)))" ) , fvc.interpolate(rho*rUA));
U.ext_assign(rUA*UEqn.H())
UEqn.clear()
phi.ext_assign( fvc.interpolate( rho )*(fvc.interpolate(U) & mesh.Sf()) )
from Foam.finiteVolume import adjustPhi
closedVolume = adjustPhi(phi, U, p);
buoyancyPhi =surfaceScalarField( rhorUAf * fvc.interpolate( rho )*( g & mesh.Sf() ) )
phi.ext_assign( phi+buoyancyPhi )
for nonOrth in range( nNonOrthCorr+1 ):
from Foam import fvm
pEqn = fvm.laplacian(rhorUAf, p) == fvc.div(phi)
pEqn.setReference(pRefCell, p[pRefCell]);
if (nonOrth == 0):
eqnResidual = pEqn.solve().initialResidual()
maxResidual = max(eqnResidual, maxResidual)
else:
pEqn.solve()
if (nonOrth == nNonOrthCorr):
if (closedVolume):
p.ext_assign( p + ( initialMass - fvc.domainIntegrate( psi * p ) ) / fvc.domainIntegrate( psi ) )
phi.ext_assign( phi - pEqn.flux() )
p.relax()
U.ext_assign( U + rUA * fvc.reconstruct( ( buoyancyPhi - pEqn.flux() ) / rhorUAf ) )
U.correctBoundaryConditions();
from Foam.finiteVolume.cfdTools.general.include import ContinuityErrs
cumulativeContErr = ContinuityErrs( phi, runTime, mesh, cumulativeContErr )
rho.ext_assign( thermo.rho() )
rho.relax()
ext_Info()<< "rho max/min : " << rho.ext_max().value() << " " << rho.ext_min().value() << nl
return eqnResidual, maxResidual, cumulativeContErr
def _hEqn( phi, h, turbulence, rho, p, thermo, eqnResidual, maxResidual ):
from Foam import fvc, fvm
hEqn = fvm.div( phi, h ) - fvm.Sp( fvc.div( phi ), h ) - fvm.laplacian( turbulence.alphaEff(), h ) \
== fvc.div( phi / fvc.interpolate( rho ) * fvc.interpolate( p ) ) - p * fvc.div( phi / fvc.interpolate( rho ) )
hEqn.relax()
eqnResidual = hEqn.solve().initialResidual()
maxResidual = max(eqnResidual, maxResidual)
thermo.correct()
return hEqn, eqnResidual, maxResidual
def fun_pEqn( runTime, mesh, UEqn, p, p_rgh, phi, U, rho, rho1, rho2, rho10, rho20, gh, ghf, dgdt, pMin, \
psi1, psi2, alpha1, alpha2, interface, transonic, oCorr, nOuterCorr, corr, nCorr, nNonOrthCorr ):
rUA = 1.0/UEqn.A()
from Foam import fvc
rUAf = fvc.interpolate( rUA )
p_rghEqnComp = None
from Foam import fvm
if transonic:
p_rghEqnComp = fvm.ddt( p_rgh ) + fvm.div( phi, p_rgh ) - fvm.Sp( fvc.div( phi ), p_rgh )
pass
else:
p_rghEqnComp = fvm.ddt( p_rgh ) + fvc.div( phi, p_rgh ) - fvc.Sp( fvc.div( phi ), p_rgh )
pass
U.ext_assign( rUA * UEqn.H() )
from Foam.finiteVolume import surfaceScalarField
from Foam.OpenFOAM import word
phiU = surfaceScalarField( word( "phiU" ),
( fvc.interpolate( U ) & mesh.Sf() ) + fvc.ddtPhiCorr( rUA, rho, U, phi ) )
phi.ext_assign(phiU + ( fvc.interpolate( interface.sigmaK() ) * fvc.snGrad( alpha1 ) - ghf * fvc.snGrad( rho ) ) * rUAf * mesh.magSf() )
from Foam.finiteVolume import solve
from Foam.OpenFOAM import scalar
for nonOrth in range( nNonOrthCorr +1 ):
p_rghEqnIncomp = fvc.div( phi ) - fvm.laplacian( rUAf, p_rgh )
solve( ( alpha1.ext_max( scalar( 0 ) ) * ( psi1 / rho1 ) + alpha2.ext_max( scalar( 0 ) ) * ( psi2 / rho2 ) ) *p_rghEqnComp() + p_rghEqnIncomp,
mesh.solver( p_rgh.select( oCorr == ( nOuterCorr - 1 ) and corr == ( nCorr-1 ) and nonOrth == nNonOrthCorr ) ) )
if nonOrth == nNonOrthCorr:
dgdt.ext_assign( ( alpha2.pos() * ( psi2 / rho2 ) - alpha1.pos() * ( psi1 / rho1 ) ) * ( p_rghEqnComp & p_rgh ) )
phi.ext_assign( phi + p_rghEqnIncomp.flux() )
pass
U.ext_assign( U + rUA * fvc.reconstruct( ( phi - phiU ) / rUAf ) )
U.correctBoundaryConditions()
p.ext_assign( ( ( p_rgh + gh * ( alpha1 * rho10 + alpha2 * rho20 ) ) /( 1.0 - gh * ( alpha1 * psi1 + alpha2 * psi2 ) ) ).ext_max( pMin ) )
rho1.ext_assign( rho10 + psi1 * p )
rho2.ext_assign( rho20 + psi2 * p )
from Foam.OpenFOAM import ext_Info, nl
ext_Info() << "max(U) " << U.mag().ext_max().value() << nl
ext_Info() << "min(p_rgh) " << p_rgh.ext_min().value() << nl
pass
def _pEqn( rho, thermo, UEqn, nNonOrthCorr, psi, U, mesh, phi, p, DpDt, cumulativeContErr, corr, nCorr, nOuterCorr, transonic ):
rho.ext_assign( thermo.rho() )
rUA = 1.0/UEqn.A()
U.ext_assign( rUA * UEqn.H() )
from Foam import fvc, fvm
from Foam.OpenFOAM import word
from Foam.finiteVolume import surfaceScalarField
if transonic:
phid = surfaceScalarField( word( "phid" ),
fvc.interpolate( psi ) * ( ( fvc.interpolate( U ) & mesh.Sf() ) + fvc.ddtPhiCorr( rUA, rho, U, phi ) ) )
for nonOrth in range( nNonOrthCorr + 1 ) :
pEqn = fvm.ddt( psi, p ) + fvm.div( phid, p ) - fvm.laplacian( rho * rUA, p )
pEqn.solve()
if nonOrth == nNonOrthCorr:
phi == pEqn.flux()
pass
pass
pass
else:
phi.ext_assign( fvc.interpolate( rho ) * ( ( fvc.interpolate(U) & mesh.Sf() ) + fvc.ddtPhiCorr( rUA, rho, U, phi ) ) )
for nonOrth in range( nNonOrthCorr + 1 ) :
pEqn = fvm.ddt( psi, p ) + fvc.div( phi ) - fvm.laplacian( rho * rUA, p )
pEqn.solve()
if nonOrth == nNonOrthCorr:
phi.ext_assign( phi + pEqn.flux() )
pass
pass
pass
from Foam.finiteVolume.cfdTools.compressible import rhoEqn
rhoEqn( rho, phi )
from Foam.finiteVolume.cfdTools.compressible import compressibleContinuityErrs
cumulativeContErr = compressibleContinuityErrs( rho, thermo, cumulativeContErr )
U.ext_assign( U - rUA * fvc.grad( p ) )
U.correctBoundaryConditions()
DpDt.ext_assign( fvc.DDt( surfaceScalarField( word( "phiU" ), phi / fvc.interpolate( rho ) ), p ) )
return cumulativeContErr
def _pEqn(mesh, UEqn, U, p, phi, alpha1, rho, g, interface, corr, nCorr, nNonOrthCorr, pRefCell, pRefValue):
rUA = 1.0 / UEqn.A()
from Foam import fvc
rUAf = fvc.interpolate(rUA)
U.ext_assign(rUA * UEqn.H())
from Foam.finiteVolume import surfaceScalarField
from Foam.OpenFOAM import word
phiU = surfaceScalarField(word("phiU"), (fvc.interpolate(U) & mesh.Sf()) + fvc.ddtPhiCorr(rUA, rho, U, phi))
from Foam.finiteVolume import adjustPhi
adjustPhi(phiU, U, p)
phi.ext_assign(
phiU
+ (
fvc.interpolate(interface.sigmaK()) * fvc.snGrad(alpha1) * mesh.magSf()
+ fvc.interpolate(rho) * (g & mesh.Sf())
)
* rUAf
)
from Foam import fvm
for nonOrth in range(nNonOrthCorr + 1):
pEqn = fvm.laplacian(rUAf, p) == fvc.div(phi)
pEqn.setReference(pRefCell, pRefValue)
if corr == nCorr - 1 and nonOrth == nNonOrthCorr:
pEqn.solve(mesh.solver(word(str(p.name()) + "Final")))
pass
else:
pEqn.solve(mesh.solver(p.name()))
pass
if nonOrth == nNonOrthCorr:
phi.ext_assign(phi - pEqn.flux())
pass
pass
U.ext_assign(U + rUA * fvc.reconstruct((phi - phiU) / rUAf))
U.correctBoundaryConditions()
pass
def fun_pEqn( i, fluidRegions, Uf, pdf, rhof, thermof, phif, ghf, Kf, DpDtf, turb, initialMassf, UEqn, pRef, corr, nCorr, nNonOrthCorr, cumulativeContErr ) :
closedVolume = False
rhof[ i ].ext_assign( thermof[ i ].rho() )
rUA = 1.0 / UEqn.A()
Uf[ i ].ext_assign( rUA * UEqn.H() )
from Foam import fvc
phif[ i ] .ext_assign( fvc.interpolate( rhof[ i ] ) * ( ( fvc.interpolate( Uf[ i ] ) & fluidRegions[ i ].Sf() ) +
fvc.ddtPhiCorr( rUA, rhof[ i ], Uf[ i ], phif[ i ] ) ) -
fvc.interpolate( rhof[ i ] * rUA * ghf[ i ] ) * fvc.snGrad( rhof[ i ] ) * fluidRegions[ i ].magSf() )
# Solve pressure difference
pdEqn, closedVolume = fun_pdEqn( corr, nCorr, nNonOrthCorr, closedVolume, pdf[i], pRef, rhof[i], thermof[i].psi(), rUA, ghf[i], phif[i] )
# Solve continuity
rhoEqn( rhof[i], phif[i] )
# Update pressure field (including bc)
from Foam.OpenFOAM import word
thermof[i].p() == pdf[ i ] + rhof[ i ] * ghf[ i ] + pRef
from Foam.finiteVolume import surfaceScalarField
DpDtf[i].ext_assign( fvc.DDt( surfaceScalarField( word( "phiU" ), phif[ i ] / fvc.interpolate( rhof[ i ] ) ), thermof[i].p() ) )
# Update continuity errors
cumulativeContErr = compressibleContinuityErrors( cumulativeContErr, rhof[i], thermof[i] )
# Correct velocity field
Uf[ i ].ext_assign( Uf[i] - rUA * ( fvc.grad( pdf[ i ] ) + fvc.grad( rhof[ i ] ) * ghf[ i ] ) )
Uf[ i ].correctBoundaryConditions()
# For closed-volume cases adjust the pressure and density levels
# to obey overall mass continuity
if (closedVolume):
from Foam.OpenFOAM import dimensionedScalar, dimMass
thermof[i].p().ext_assign( thermof[i].p() +
( dimensionedScalar( word( "massIni" ),
dimMass,
initialMassf[ i ] ) - fvc.domainIntegrate( thermof[ i ].psi() * thermof[ i ].p() ) )
/ fvc.domainIntegrate( thermof[ i ].psi() ) )
rhof[ i ].ext_assign( thermof[ i ].rho() )
# Update thermal conductivity
Kf[i].ext_assign( rhof[ i ] * thermof[ i ].Cp() * turb[ i ].alphaEff() )
return cumulativeContErr
def compressibleCourantNo_010600_dev( mesh, phi, rho, runTime ):
from Foam.OpenFOAM import Time
from Foam.finiteVolume import fvMesh
from Foam.finiteVolume import surfaceScalarField
CoNum = 0.0
meanCoNum = 0.0
velMag = 0.0
if mesh.nInternalFaces() :
from Foam import fvc
phiOverRho = phi.mag() / fvc.interpolate( rho )
SfUfbyDelta = mesh.deltaCoeffs() * phiOverRho
CoNum = ( SfUfbyDelta / mesh.magSf() ).ext_max().value() * runTime.deltaT().value()
meanCoNum = ( SfUfbyDelta.sum() / mesh.magSf().sum() ).value() * runTime.deltaT().value();
velMag = ( phiOverRho / mesh.magSf() ).ext_max().value()
pass
from Foam.OpenFOAM import ext_Info, nl
ext_Info() << "Courant Number mean: " << meanCoNum << " max: " << CoNum << " velocity magnitude: " << velMag << nl
return CoNum, meanCoNum, velMag
def solidRegionDiffNo( mesh, runTime, Cprho, K ):
DiNum = 0.0
meanDiNum = 0.0
#- Can have fluid domains with 0 cells so do not test.
if mesh.nInternalFaces():
from Foam import fvc
KrhoCpbyDelta = mesh.deltaCoeffs() * fvc.interpolate( K ) / fvc.interpolate(Cprho);
DiNum = KrhoCpbyDelta.internalField().max() * runTime.deltaT().value()
meanDiNum = KrhoCpbyDelta.average().value() * runTime.deltaT().value()
pass
from Foam.OpenFOAM import ext_Info, nl
ext_Info() << "Region: " << mesh.name() << " Diffusion Number mean: " << meanDiNum << " max: " << DiNum << nl
return DiNum
def step(self, getPISOControls):
from Foam.OpenFOAM import ext_Info, nl
ext_Info() << "Time = " << self.runTime.timeName() << nl << nl
piso, nCorr, nNonOrthCorr, momentumPredictor, transonic, nOuterCorr = getPISOControls(self.mesh)
from Foam.finiteVolume.cfdTools.incompressible import CourantNo
CoNum, meanCoNum = CourantNo(self.mesh, self.phi, self.runTime)
from Foam import fvm
UEqn = fvm.ddt(self.U) + fvm.div(self.phi, self.U) - fvm.laplacian(self.nu, self.U)
from Foam import fvc
from Foam.finiteVolume import solve
solve(UEqn == -fvc.grad(self.p))
# --- PISO loop
for corr in range(nCorr):
rUA = 1.0 / UEqn.A()
self.U.ext_assign(rUA * UEqn.H())
self.phi.ext_assign((fvc.interpolate(self.U) & self.mesh.Sf()) + fvc.ddtPhiCorr(rUA, self.U, self.phi))
from Foam.finiteVolume import adjustPhi
adjustPhi(self.phi, self.U, self.p)
for nonOrth in range(nNonOrthCorr + 1):
pEqn = fvm.laplacian(rUA, self.p) == fvc.div(self.phi)
pEqn.setReference(self.pRefCell, self.pRefValue)
pEqn.solve()
if nonOrth == nNonOrthCorr:
self.phi.ext_assign(self.phi - pEqn.flux())
pass
pass
from Foam.finiteVolume.cfdTools.incompressible import continuityErrs
cumulativeContErr = continuityErrs(self.mesh, self.phi, self.runTime, self.cumulativeContErr)
self.U.ext_assign(self.U - rUA * fvc.grad(self.p))
self.U.correctBoundaryConditions()
pass
self.runTime.write()
ext_Info() << "ExecutionTime = " << self.runTime.elapsedCpuTime() << " s" << " ClockTime = " << self.runTime.elapsedClockTime() << " s" << nl << nl
self.runTime += self.runTime.deltaT()
return self.runTime.value()
def fun_UEqn(mesh, U, p_rgh, ghf, rho, rhoPhi, turbulence, twoPhaseProperties, momentumPredictor, finalIter):
from Foam.OpenFOAM import word
from Foam.finiteVolume import surfaceScalarField
from Foam import fvc
muEff = surfaceScalarField(word("muEff"), twoPhaseProperties.muf() + fvc.interpolate(rho * turbulence.ext_nut()))
from Foam import fvm, fvc
UEqn = fvm.ddt(rho, U) + fvm.div(rhoPhi, U) - fvm.laplacian(muEff, U) - (fvc.grad(U) & fvc.grad(muEff))
if finalIter:
UEqn.relax(1.0)
pass
else:
UEqn.relax()
pass
if momentumPredictor:
from Foam.finiteVolume import solve
solve(
UEqn == fvc.reconstruct((-ghf * fvc.snGrad(rho) - fvc.snGrad(p_rgh)) * mesh.magSf()),
mesh.solver(U.select(finalIter)),
)
pass
return UEqn
def main_standalone( argc, argv ):
from Foam.OpenFOAM import argList, word
argList.validOptions.fget().insert( word( "writep" ), "" )
from Foam.OpenFOAM.include import setRootCase
args = setRootCase( argc, argv )
from Foam.OpenFOAM.include import createTime
runTime = createTime( args )
from Foam.OpenFOAM.include import createMesh
mesh = createMesh( runTime )
p, U, phi, pRefCell, pRefValue = _createFields( runTime, mesh )
from Foam.OpenFOAM import ext_Info, nl
ext_Info() << nl << "Calculating potential flow" << nl
from Foam.finiteVolume.cfdTools.general.include import readSIMPLEControls
simple, nNonOrthCorr, momentumPredictor, fluxGradp, transonic = readSIMPLEControls( mesh )
from Foam.finiteVolume import adjustPhi
adjustPhi(phi, U, p)
from Foam.OpenFOAM import dimensionedScalar, word, dimTime, dimensionSet
from Foam import fvc, fvm
for nonOrth in range( nNonOrthCorr + 1):
pEqn = fvm.laplacian( dimensionedScalar( word( "1" ), dimTime / p.dimensions() * dimensionSet( 0.0, 2.0, -2.0, 0.0, 0.0 ), 1.0 ), p ) == fvc.div( phi )
pEqn.setReference( pRefCell, pRefValue )
pEqn.solve()
if nonOrth == nNonOrthCorr:
phi.ext_assign( phi - pEqn.flux() )
pass
pass
ext_Info() << "continuity error = " << fvc.div( phi ).mag().weightedAverage( mesh.V() ).value() << nl
U.ext_assign( fvc.reconstruct( phi ) )
U.correctBoundaryConditions()
ext_Info() << "Interpolated U error = " << ( ( ( fvc.interpolate( U ) & mesh.Sf() ) - phi ).sqr().sum().sqrt() /mesh.magSf().sum() ).value() << nl
# Force the write
U.write()
phi.write()
if args.optionFound( word( "writep" ) ):
p.write()
pass
ext_Info() << "ExecutionTime = " << runTime.elapsedCpuTime() << " s" << \
" ClockTime = " << runTime.elapsedClockTime() << " s" << nl << nl
ext_Info() << "End\n" << nl
import os
return os.EX_OK
def _eEqn( rho, e, phi, turbulence, p, thermo ):
from Foam import fvm, fvc
from Foam.finiteVolume import solve
solve( fvm.ddt( rho, e ) + fvm.div( phi, e ) - fvm.laplacian( turbulence.alphaEff(), e )
== - p * fvc.div( phi / fvc.interpolate( rho ) ) )
thermo.correct()
pass
def create_fields( runTime, mesh ):
from Foam.OpenFOAM import ext_Info, nl
ext_Info() << "Reading thermophysical properties\n" << nl
from Foam.thermophysicalModels import basicPsiThermo, autoPtr_basicPsiThermo
thermo = basicPsiThermo.New( mesh )
p = thermo.p()
h = thermo.h()
psi = thermo.psi()
from Foam.OpenFOAM import IOobject, word, fileName
from Foam.finiteVolume import volScalarField
rho = volScalarField( IOobject( word( "rho" ),
fileName( runTime.timeName() ),
mesh,
IOobject.READ_IF_PRESENT,
IOobject.AUTO_WRITE ),
thermo.rho() )
ext_Info() << "Reading field U\n" << nl
from Foam.finiteVolume import volVectorField
U = volVectorField( IOobject( word( "U" ),
fileName( runTime.timeName() ),
mesh,
IOobject.MUST_READ,
IOobject.AUTO_WRITE ),
mesh )
from Foam.finiteVolume.cfdTools.compressible import compressibleCreatePhi
phi = compressibleCreatePhi( runTime, mesh, rho, U )
from Foam.OpenFOAM import dimensionedScalar
pMin = dimensionedScalar( mesh.solutionDict().subDict( word( "PIMPLE" ) ).lookup( word( "pMin" ) ) )
ext_Info() << "Creating turbulence model\n" << nl
from Foam import compressible
turbulence = compressible.turbulenceModel.New( rho, U, phi, thermo() )
# initialMass = fvc.domainIntegrate(rho)
ext_Info() << "Creating field DpDt\n" << nl
from Foam import fvc
from Foam.finiteVolume import surfaceScalarField
DpDt = fvc.DDt( surfaceScalarField( word( "phiU" ), phi / fvc.interpolate( rho ) ), p )
from Foam.finiteVolume import MRFZones
mrfZones = MRFZones( mesh )
mrfZones.correctBoundaryVelocity( U )
from Foam.finiteVolume import porousZones
pZones = porousZones( mesh )
from Foam.OpenFOAM import Switch
pressureImplicitPorosity = Switch( False )
return thermo, turbulence, p, h, psi, rho, U, phi, pMin, DpDt, mrfZones, pZones, pressureImplicitPorosity
def fun_pEqn( mesh, p, U, trTU, trAU, UEqn, phi, runTime, pressureImplicitPorosity, nNonOrthCorr, \
eqnResidual, maxResidual, cumulativeContErr, pRefCell, pRefValue, ):
if pressureImplicitPorosity :
U.ext_assign( trTU & UEqn.H() )
pass
else:
U.ext_assign( trAU * UEqn.H() )
pass
UEqn.clear()
from Foam import fvc, fvm
phi.ext_assign( fvc.interpolate( U ) & mesh.Sf() )
from Foam.finiteVolume import adjustPhi
adjustPhi( phi, U, p )
for nonOrth in range( nNonOrthCorr + 1 ) :
tpEqn = None
if pressureImplicitPorosity :
tpEqn = ( fvm.laplacian( trTU, p ) == fvc.div( phi ) )
pass
else:
tpEqn = ( fvm.laplacian( trAU, p ) == fvc.div( phi ) )
pass
tpEqn.setReference( pRefCell, pRefValue )
# retain the residual from the first iteration
if nonOrth == 0 :
eqnResidual = tpEqn.solve().initialResidual()
maxResidual = max( eqnResidual, maxResidual )
pass
else:
tpEqn.solve()
pass
if nonOrth == nNonOrthCorr :
phi.ext_assign( phi - tpEqn.flux() )
pass
pass
from Foam.finiteVolume.cfdTools.incompressible import continuityErrs
cumulativeContErr = continuityErrs( mesh, phi, runTime, cumulativeContErr )
# Explicitly relax pressure for momentum corrector
p.relax()
if pressureImplicitPorosity :
U.ext_assign( U - ( trTU & fvc.grad( p ) ) )
else:
U.ext_assign( U - ( trAU * fvc.grad( p ) ) )
pass
U.correctBoundaryConditions()
return eqnResidual, maxResidual
def fun_hEqn( turbulence, phi, h, rho, radiation, p, thermo, eqnResidual, maxResidual ):
from Foam import fvc, fvm
left_exp = fvm.div( phi, h ) - fvm.Sp( fvc.div( phi ), h ) - fvm.laplacian( turbulence.alphaEff(), h )
right_exp = fvc.div( phi/fvc.interpolate( rho )*fvc.interpolate( p ) ) - p*fvc.div( phi/fvc.interpolate( rho ) ) + radiation.Sh( thermo() )
hEqn = (left_exp == right_exp )
hEqn.relax()
eqnResidual = hEqn.solve().initialResidual()
maxResidual = max(eqnResidual, maxResidual)
thermo.correct()
radiation.correct()
return hEqn, eqnResidual, maxResidual
def _hEqn(thermo, phi, h, turbulence, p, rho):
from Foam.finiteVolume import fvScalarMatrix
from Foam import fvc, fvm
left_expr = fvm.div(phi, h) - fvm.Sp(fvc.div(phi), h) - fvm.laplacian(turbulence.alphaEff(), h)
from Foam.OpenFOAM import word
right_expr = fvc.div(phi / fvc.interpolate(rho) * fvc.interpolate(p, word("div(U,p)"))) - p * fvc.div(
phi / fvc.interpolate(rho)
)
hEqn = left_expr == right_expr
hEqn.relax()
hEqn.solve()
thermo.correct()
return hEqn
def Ueqn( mesh, phi, U, rho, p, g, turbulence, eqnResidual, maxResidual ):
from Foam import fvm, fvc
UEqn = fvm.div( phi, U ) + turbulence.divDevRhoReff( U )
UEqn.relax()
from Foam.finiteVolume import solve
eqnResidual = solve( UEqn() == fvc.reconstruct( fvc.interpolate( rho )*( g & mesh.Sf() ) - fvc.snGrad( p ) * mesh.magSf() ) ).initialResidual()
maxResidual = max(eqnResidual, maxResidual)
return UEqn, eqnResidual, maxResidual
def _UEqn( mesh, alpha1, U, p, rho, rhoPhi, turbulence, g, twoPhaseProperties, interface, momentumPredictor ):
from Foam.OpenFOAM import word
from Foam.finiteVolume import surfaceScalarField
from Foam import fvc
muEff = surfaceScalarField( word( "muEff" ),
twoPhaseProperties.muf() + fvc.interpolate( rho * turbulence.ext_nut() ) )
from Foam import fvm
UEqn = fvm.ddt( rho, U ) + fvm.div( rhoPhi, U ) - fvm.laplacian( muEff, U ) - ( fvc.grad( U ) & fvc.grad( muEff ) )
UEqn.relax()
if momentumPredictor:
from Foam.finiteVolume import solve
solve( UEqn == \
fvc.reconstruct( fvc.interpolate( rho ) * ( g & mesh.Sf() ) + \
( fvc.interpolate( interface.sigmaK() ) * fvc.snGrad( alpha1 ) - fvc.snGrad( p ) ) * mesh.magSf() ) )
pass
return UEqn
def fun_UEqn( mesh, alpha1, U, p, p_rgh, ghf, rho, rhoPhi, turbulence, g, twoPhaseProperties, interface, momentumPredictor, oCorr, nOuterCorr ):
from Foam.OpenFOAM import word
from Foam.finiteVolume import surfaceScalarField
from Foam import fvc
muEff = surfaceScalarField( word( "muEff" ),
twoPhaseProperties.muf() + fvc.interpolate( rho * turbulence.ext_nut() ) )
from Foam import fvm
UEqn = fvm.ddt( rho, U ) + fvm.div( rhoPhi, U ) - fvm.laplacian( muEff, U ) - ( fvc.grad( U ) & fvc.grad( muEff ) )
UEqn.relax()
if momentumPredictor:
from Foam.finiteVolume import solve
solve( UEqn == \
fvc.reconstruct( ( fvc.interpolate( interface.sigmaK() ) * fvc.snGrad( alpha1 ) - ghf * fvc.snGrad( rho ) \
- fvc.snGrad( p_rgh ) ) * mesh.magSf(),
mesh.solver( U.select( oCorr == nOuterCorr-1 ) ) ) )
pass
return UEqn
def pEqn(
runTime, mesh, p, phi, U, UEqn, eqnResidual, maxResidual, nNonOrthCorr, cumulativeContErr, pRefCell, pRefValue
):
p.ext_boundaryField().updateCoeffs()
AU = UEqn.A()
U.ext_assign(UEqn.H() / AU)
UEqn.clear()
from Foam import fvc
phi.ext_assign(fvc.interpolate(U) & mesh.Sf())
from Foam.finiteVolume import adjustPhi
adjustPhi(phi, U, p)
# Non-orthogonal pressure corrector loop
for nonOrth in range(nNonOrthCorr + 1):
from Foam import fvm, fvc
pEqn = fvm.laplacian(1.0 / AU, p) == fvc.div(phi)
pEqn.setReference(pRefCell, pRefValue)
# retain the residual from the first iteration
if nonOrth == 0:
eqnResidual = pEqn.solve().initialResidual()
maxResidual = max(eqnResidual, maxResidual)
pass
else:
pEqn.solve()
pass
if nonOrth == nNonOrthCorr:
phi.ext_assign(phi - pEqn.flux())
pass
pass
from Foam.finiteVolume.cfdTools.incompressible import continuityErrs
cumulativeContErr = continuityErrs(mesh, phi, runTime, cumulativeContErr)
# Explicitly relax pressure for momentum corrector
p.relax()
# Momentum corrector
U.ext_assign(U - fvc.grad(p) / AU)
U.correctBoundaryConditions()
return eqnResidual, maxResidual, cumulativeContErr
def _pEqn( runTime, mesh, U, UEqn, phi, p, rhok, g, corr, nCorr, nNonOrthCorr, cumulativeContErr ):
from Foam.finiteVolume import volScalarField, surfaceScalarField
from Foam.OpenFOAM import word
from Foam import fvc
rUA = volScalarField( word( "rUA" ), 1.0 / UEqn.A() )
rUAf = surfaceScalarField(word( "(1|A(U))" ), fvc.interpolate( rUA ) )
U.ext_assign( rUA * UEqn.H() )
phiU = ( fvc.interpolate( U ) & mesh.Sf() ) + fvc.ddtPhiCorr( rUA, U, phi )
phi.ext_assign( phiU + rUAf * fvc.interpolate( rhok ) * ( g & mesh.Sf() ) )
for nonOrth in range( nNonOrthCorr+1 ):
from Foam import fvm
pEqn = fvm.laplacian( rUAf, p ) == fvc.div( phi )
if ( corr == nCorr-1 ) and (nonOrth == nNonOrthCorr):
from Foam.OpenFOAM import word
pEqn.solve(mesh.solver( word( str( p.name() ) + "Final" ) ) )
pass
else:
pEqn.solve( mesh.solver( p.name() ) )
pass
if (nonOrth == nNonOrthCorr):
phi.ext_assign( phi - pEqn.flux() )
pass
pass
U.ext_assign( U + rUA * fvc.reconstruct( ( phi - phiU ) / rUAf ) )
U.correctBoundaryConditions()
from Foam.finiteVolume.cfdTools.incompressible import continuityErrs
cumulativeContErr = continuityErrs( mesh, phi, runTime, cumulativeContErr )
return pEqn
def CourantNo( runTime, mesh, h, phi, magg ):
CoNum = 0.0
meanCoNum = 0.0
waveCoNum = 0.0
if mesh.nInternalFaces():
from Foam import fvc
SfUfbyDelta = mesh.deltaCoeffs() * phi.mag() / fvc.interpolate(h)
CoNum = ( SfUfbyDelta / mesh.magSf() ).ext_max().value() * runTime.deltaT().value()
meanCoNum = ( SfUfbyDelta.sum() / mesh.magSf().sum() ).value() * runTime.deltaT().value()
# Gravity wave Courant number
waveCoNum = 0.5 * ( mesh.deltaCoeffs() * fvc.interpolate( h ).sqrt() ).ext_max().value() * magg.sqrt().value() * runTime.deltaT().value()
from Foam.OpenFOAM import ext_Info, nl
ext_Info() << "Courant number mean: " << meanCoNum << " max: " << CoNum << nl
ext_Info() << "Gravity wave Courant number max: " << waveCoNum << nl
return CoNum, meanCoNum, waveCoNum
def _Ueqn( U, phi, turbulence, p, rhok, g, mesh, momentumPredictor ):
from Foam import fvm
# Solve the momentum equation
UEqn = fvm.ddt( U ) + fvm.div( phi, U ) + turbulence.divDevReff( U )
UEqn.relax()
from Foam.finiteVolume import solve
from Foam import fvc
if momentumPredictor:
solve( UEqn == fvc.reconstruct( ( fvc.interpolate( rhok ) * ( g & mesh.Sf() ) - fvc.snGrad( p ) * mesh.magSf() ) ) )
return UEqn
