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 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 create_fields(runTime, mesh, g):
from Foam.OpenFOAM import ext_Info, nl
ext_Info() << "Reading thermophysical properties\n" << nl
from Foam.thermophysicalModels import basicRhoThermo
thermo = basicRhoThermo.New(mesh)
from Foam.OpenFOAM import IOobject, word, fileName
from Foam.finiteVolume import volScalarField
rho = volScalarField(
IOobject(word("rho"), fileName(runTime.timeName()), mesh,
IOobject.NO_READ, IOobject.NO_WRITE), thermo.rho())
p = thermo.p()
h = thermo.h()
psi = thermo.psi()
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)
ext_Info() << "Creating turbulence model\n" << nl
from Foam import compressible
turbulence = compressible.turbulenceModel.New(rho, U, phi, thermo())
ext_Info() << "Calculating field g.h\n" << nl
gh = volScalarField(word("gh"), g & mesh.C())
from Foam.finiteVolume import surfaceScalarField
ghf = surfaceScalarField(word("ghf"), g & mesh.Cf())
ext_Info() << "Reading field p_rgh\n" << nl
p_rgh = volScalarField(
IOobject(word("p_rgh"), fileName(runTime.timeName()), mesh,
IOobject.MUST_READ, IOobject.AUTO_WRITE), mesh)
# Force p_rgh to be consistent with p
p_rgh.ext_assign(p - rho * gh)
ext_Info() << "Creating field DpDt\n" << nl
from Foam import fvc
DpDt = volScalarField(
word("DpDt"),
fvc.DDt(surfaceScalarField(word("phiU"), phi / fvc.interpolate(rho)),
p))
return thermo, p, rho, h, psi, U, phi, turbulence, gh, ghf, p_rgh, DpDt
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 _createFields(runTime, mesh, g):
from Foam.OpenFOAM import ext_Info, nl
ext_Info() << "Reading thermophysical properties\n" << nl
from Foam.thermophysicalModels import basicRhoThermo
thermo = basicRhoThermo.New(mesh)
from Foam.OpenFOAM import IOdictionary, IOobject, word, fileName
from Foam.finiteVolume import volScalarField
rho = volScalarField(
IOobject(word("rho"), fileName(runTime.timeName()), mesh,
IOobject.NO_READ, IOobject.NO_WRITE), thermo.rho())
p = thermo.p()
h = thermo.h()
psi = thermo.psi()
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)
ext_Info() << "Creating turbulence model\n" << nl
from Foam import compressible
turbulence = compressible.turbulenceModel.New(rho, U, phi, thermo())
ext_Info() << "Creating field DpDt\n" << nl
from Foam import fvc
from Foam.finiteVolume import surfaceScalarField
DpDt = volScalarField(
word("DpDt"),
fvc.DDt(surfaceScalarField(word("phiU"), phi / fvc.interpolate(rho)),
p))
thermo.correct()
initialMass = fvc.domainIntegrate(rho)
totalVolume = mesh.V().ext_sum()
return thermo, p, h, psi, phi, rho, U, turbulence, DpDt, initialMass, totalVolume
def _createFields(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 IOdictionary, 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())
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)
return p, h, psi, rho, U, phi, turbulence, thermo, pMin, DpDt
def fun_pEqn(mesh, thermo, p, rho, psi, U, phi, DpDt, pMin, UEqn, mrfZones,
nNonOrthCorr, nCorr, oCorr, nOuterCorr, corr, transonic,
cumulativeContErr):
rho.ext_assign(thermo.rho())
rUA = 1.0 / UEqn.A()
U.ext_assign(rUA * UEqn.H())
if nCorr <= 1:
UEqn.clear()
pass
if transonic:
from Foam.finiteVolume import surfaceScalarField
from Foam.OpenFOAM import word
phid = surfaceScalarField(
word("phid"),
fvc.interpolate(psi) * ((fvc.interpolate(U) & mesh.Sf()) +
fvc.ddtPhiCorr(rUA, rho, U, phi)))
mrfZones.relativeFlux(fvc.interpolate(psi), phid)
from Foam import fvm
for nonOrth in range(nNonOrthCorr + 1):
pEqn = fvm.ddt(psi, p) + fvm.div(phid, p) - fvm.laplacian(
rho * rUA, p)
if oCorr == (nOuterCorr - 1) and (corr == nCorr -
1) and (nonOrth == nNonOrthCorr):
from Foam.OpenFOAM import word
pEqn.solve(mesh.solver(word("pFinal")))
pass
else:
pEqn.solve()
pass
if nonOrth == nNonOrthCorr:
phi == pEqn.flux()
pass
else:
from Foam import fvc
phi.ext_assign(
fvc.interpolate(rho) * ((fvc.interpolate(U) & mesh.Sf())))
mrfZones.relativeFlux(fvc.interpolate(rho), phi)
from Foam import fvm
for nonOrth in range(nNonOrthCorr + 1):
# Pressure corrector
pEqn = fvm.ddt(psi, p) + fvc.div(phi) - fvm.laplacian(rho * rUA, p)
if oCorr == (nOuterCorr - 1) and corr == (
nCorr - 1) and nonOrth == nNonOrthCorr:
from Foam.OpenFOAM import word
pEqn.solve(mesh.solver(word("pFinal")))
pass
else:
pEqn.solve()
pass
if nonOrth == nNonOrthCorr:
phi.ext_assign(phi + 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)
# Explicitly relax pressure for momentum corrector
p.relax()
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
U.ext_assign(U - rUA * fvc.grad(p))
U.correctBoundaryConditions()
from Foam.finiteVolume import surfaceScalarField
from Foam.OpenFOAM import word
DpDt.ext_assign(
fvc.DDt(surfaceScalarField(word("phiU"), phi / fvc.interpolate(rho)),
p))
from Foam.finiteVolume import bound
bound(p, pMin)
pass
def main_standalone(argc, argv):
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)
thermo, p, h, psi, rho, U, phi, turbulence, DpDt = createFields(
runTime, mesh)
from Foam.finiteVolume.cfdTools.general.include import initContinuityErrs
cumulativeContErr = initContinuityErrs()
from Foam.OpenFOAM import ext_Info, nl
ext_Info() << "\nStarting time loop\n" << nl
runTime.increment()
while not runTime.end():
ext_Info() << "Time = " << runTime.timeName() << nl << nl
from Foam.finiteVolume.cfdTools.general.include import readPISOControls
piso, nCorr, nNonOrthCorr, momentumPredictor, transonic, nOuterCorr, ddtPhiCorr = readPISOControls(
mesh)
from Foam.finiteVolume.cfdTools.compressible import compressibleCourantNo
CoNum, meanCoNum = compressibleCourantNo(mesh, phi, rho, runTime)
from Foam.finiteVolume.cfdTools.compressible import rhoEqn
rhoEqn(rho, phi)
UEqn = _UEqn(U, rho, phi, turbulence, p)
_hEqn(rho, h, phi, turbulence, DpDt, thermo)
# -------PISO loop
for corr in range(nCorr):
cumulativeContErr = _pEqn(rho, thermo, UEqn, nNonOrthCorr, psi, U,
mesh, phi, p, cumulativeContErr)
pass
from Foam import fvc
from Foam.finiteVolume import surfaceScalarField
from Foam.OpenFOAM import word
DpDt = fvc.DDt(
surfaceScalarField(word("phiU"), phi / fvc.interpolate(rho)), p)
turbulence.correct()
rho.ext_assign(psi * p)
runTime.write()
ext_Info() << "ExecutionTime = " << runTime.elapsedCpuTime() << " s" << \
" ClockTime = " << runTime.elapsedClockTime() << " s" << nl << nl
runTime.increment()
pass
ext_Info() << "End\n"
import os
return os.EX_OK
def createFluidFields(fluidRegions, runTime):
# Load boundary conditions
from .. import derivedFvPatchFields
# Initialise fluid field pointer lists
from Foam.finiteVolume import PtrList_volScalarField
rhoFluid = PtrList_volScalarField(fluidRegions.size())
KFluid = PtrList_volScalarField(fluidRegions.size())
from Foam.finiteVolume import PtrList_volVectorField
UFluid = PtrList_volVectorField(fluidRegions.size())
from Foam.finiteVolume import PtrList_surfaceScalarField
phiFluid = PtrList_surfaceScalarField(fluidRegions.size())
DpDtFluid = PtrList_volScalarField(fluidRegions.size())
from Foam.OpenFOAM import PtrList_uniformDimensionedVectorField
gFluid = PtrList_uniformDimensionedVectorField(fluidRegions.size())
from Foam.compressible import PtrList_compressible_turbulenceModel
turbulence = PtrList_compressible_turbulenceModel(fluidRegions.size())
from Foam.thermophysicalModels import PtrList_basicPsiThermo
thermoFluid = PtrList_basicPsiThermo(fluidRegions.size())
p_rghFluid = PtrList_volScalarField(fluidRegions.size())
ghFluid = PtrList_volScalarField(fluidRegions.size())
ghfFluid = PtrList_surfaceScalarField(fluidRegions.size())
from Foam.OpenFOAM import scalarList
initialMassFluid = scalarList(fluidRegions.size())
#Populate fluid field pointer lists
for index in range(fluidRegions.size()):
from Foam.OpenFOAM import ext_Info, nl
ext_Info() << "*** Reading fluid mesh thermophysical properties for region " \
<< fluidRegions[ index ].name() << nl << nl
ext_Info() << " Adding to thermoFluid\n" << nl
from Foam.thermophysicalModels import autoPtr_basicPsiThermo, basicPsiThermo
thermo = basicPsiThermo.New(fluidRegions[index])
thermoFluid.ext_set(index, thermo)
ext_Info() << " Adding to rhoFluid\n" << nl
from Foam.OpenFOAM import word, fileName, IOobject
from Foam.finiteVolume import volScalarField
rhoFluid.ext_set(
index,
volScalarField(
IOobject(word("rho"), fileName(runTime.timeName()),
fluidRegions[index], IOobject.NO_READ,
IOobject.AUTO_WRITE), thermoFluid[index].rho()))
ext_Info() << " Adding to KFluid\n" << nl
KFluid.ext_set(
index,
volScalarField(
IOobject(word("K"), fileName(runTime.timeName()),
fluidRegions[index], IOobject.NO_READ,
IOobject.NO_WRITE),
thermoFluid[index].Cp().ptr() * thermoFluid[index].alpha()))
ext_Info() << " Adding to UFluid\n" << nl
from Foam.finiteVolume import volVectorField
UFluid.ext_set(
index,
volVectorField(
IOobject(word("U"), fileName(runTime.timeName()),
fluidRegions[index], IOobject.MUST_READ,
IOobject.AUTO_WRITE), fluidRegions[index]))
ext_Info() << " Adding to phiFluid\n" << nl
from Foam.finiteVolume import surfaceScalarField
from Foam.finiteVolume import linearInterpolate
phiFluid.ext_set(
index,
surfaceScalarField(
IOobject(word("phi"), fileName(runTime.timeName()),
fluidRegions[index], IOobject.READ_IF_PRESENT,
IOobject.AUTO_WRITE),
linearInterpolate(rhoFluid[index] * UFluid[index])
& fluidRegions[index].Sf()))
ext_Info() << " Adding to gFluid\n" << nl
from Foam.OpenFOAM import uniformDimensionedVectorField
gFluid.ext_set(
index,
uniformDimensionedVectorField(
IOobject(word("g"), fileName(runTime.constant()),
fluidRegions[index], IOobject.MUST_READ,
IOobject.NO_WRITE)))
ext_Info() << " Adding to turbulence\n" << nl
from Foam import compressible
turbulence.ext_set(
index,
compressible.turbulenceModel.New(rhoFluid[index], UFluid[index],
phiFluid[index],
thermoFluid[index]))
ext_Info() << " Adding to ghFluid\n" << nl
ghFluid.ext_set(
index,
volScalarField(word("gh"),
gFluid[index] & fluidRegions[index].C()))
ext_Info() << " Adding to ghfFluid\n" << nl
ghfFluid.ext_set(
index,
surfaceScalarField(word("ghf"),
gFluid[index] & fluidRegions[index].Cf()))
p_rghFluid.ext_set(
index,
volScalarField(
IOobject(word("p_rgh"), fileName(runTime.timeName()),
fluidRegions[index], IOobject.MUST_READ,
IOobject.AUTO_WRITE), fluidRegions[index]))
# Force p_rgh to be consistent with p
p_rghFluid[index].ext_assign(thermoFluid[index].p() -
rhoFluid[index] * ghFluid[index])
from Foam import fvc
initialMassFluid[index] = fvc.domainIntegrate(rhoFluid[index]).value()
ext_Info() << " Adding to DpDtFluid\n" << nl
DpDtFluid.ext_set(
index,
volScalarField(
word("DpDt"),
fvc.DDt(
surfaceScalarField(
word("phiU"),
phiFluid[index] / fvc.interpolate(rhoFluid[index])),
thermoFluid[index].p())))
return thermoFluid, rhoFluid, KFluid, UFluid, phiFluid, gFluid, turbulence, DpDtFluid, initialMassFluid, ghFluid, ghfFluid, p_rghFluid
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(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
phif.ext_set( index, surfaceScalarField( IOobject( word( "phi" ),
fileName( runTime.timeName() ),
fluidRegions[ index ],
IOobject.READ_IF_PRESENT,
IOobject.AUTO_WRITE ),
linearInterpolate( rhof[ index ]*Uf[ index ] ) & fluidRegions[ index ].Sf() ) )
ext_Info() << " Adding to turb\n" << nl
from Foam import compressible
turb.ext_set( index, compressible.RASModel.New( rhof[ index ], Uf[ index ], phif[ index ], thermof[ index ] ) )
ext_Info() << " Adding to DpDtf\n" << nl
from Foam import fvc
DpDtf.ext_set( index, volScalarField( fvc.DDt( surfaceScalarField( word( "phiU" ),
phif[ index ] / fvc.interpolate( rhof[ index ] ) ),
thermof[ index ].p() ) ) )
from Foam.OpenFOAM import IOdictionary
environmentalProperties = IOdictionary.ext_lookupObject( fluidRegions[ index ], word( "environmentalProperties" ) )
from Foam.OpenFOAM import dimensionedVector
g = dimensionedVector( environmentalProperties.lookup( word( "g" ) ) )
ext_Info() << " Adding to ghf\n" << nl
ghf.ext_set( index, volScalarField( word( "gh" ),
g & fluidRegions[ index ].C() ) )
ext_Info() << " Updating p from pd\n" << nl
thermof[ index ].p() == pdf[ index ] + rhof[ index ] * ghf[ index ] + pRef
thermof[ index ].correct()
