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( 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 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(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 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 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 compressibleContinuityErrs( rho, thermo, cumulativeContErr ):
from Foam import fvc
totalMass = fvc.domainIntegrate( rho )
sumLocalContErr = ( fvc.domainIntegrate( ( rho - thermo.rho() ).mag() ) / totalMass ).value()
globalContErr = ( fvc.domainIntegrate( rho - thermo.rho() ) / totalMass ).value()
cumulativeContErr += globalContErr
from Foam.OpenFOAM import ext_Info, nl
ext_Info() << "time step continuity errors : sum local = " << sumLocalContErr\
<< ", global = " << globalContErr \
<< ", cumulative = " << cumulativeContErr << nl
return cumulativeContErr
def compressibleContinuityErrs(rho, thermo, cumulativeContErr):
from Foam import fvc
totalMass = fvc.domainIntegrate(rho)
sumLocalContErr = (fvc.domainIntegrate(
(rho - thermo.rho()).mag()) / totalMass).value()
globalContErr = (fvc.domainIntegrate(rho - thermo.rho()) /
totalMass).value()
cumulativeContErr += globalContErr
from Foam.OpenFOAM import ext_Info, nl
ext_Info() << "time step continuity errors : sum local = " << sumLocalContErr\
<< ", global = " << globalContErr \
<< ", cumulative = " << cumulativeContErr << nl
return cumulativeContErr
def compressibleContinuityErrors( cumulativeContErr, rho, thermo ) :
from Foam import fvc
totalMass = fvc.domainIntegrate(rho)
sumLocalContErr = (fvc.domainIntegrate( ( rho - thermo.rho() ).mag() ) / totalMass ).value()
globalContErr = ( fvc.domainIntegrate( rho - thermo.rho() ) / totalMass ).value()
cumulativeContErr = cumulativeContErr + globalContErr
regionName = rho.mesh().name()
from Foam.OpenFOAM import ext_Info, nl
ext_Info()<< "time step continuity errors (" << regionName << ")" \
<< ": sum local = " << sumLocalContErr \
<< ", global = " << globalContErr \
<< ", cumulative = " << cumulativeContErr \
<< nl
return cumulativeContErr
def createFields(runTime, mesh, g):
ext_Info() << "Reading thermophysical properties\n" << nl
from Foam.thermophysicalModels import autoPtr_basicPsiThermo, basicPsiThermo
thermo = basicPsiThermo.New(mesh)
from Foam.finiteVolume import volScalarField
from Foam.OpenFOAM import IOobject, word, fileName
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.RASModel.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)
pRefCell = 0
pRefValue = 0.0
from Foam.finiteVolume import setRefCell
pRefCell, pRefValue = setRefCell(
p, p_rgh,
mesh.solutionDict().subDict(word("SIMPLE")), pRefCell, pRefValue)
from Foam import fvc
initialMass = fvc.domainIntegrate(rho)
totalVolume = mesh.V().ext_sum()
return thermo, rho, p, h, psi, U, phi, turbulence, gh, ghf, p_rgh, pRefCell, pRefValue, 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
thermo = basicPsiThermo.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.READ_IF_PRESENT,
IOobject.AUTO_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 )
pRefCell = 0
pRefValue = 0.0
from Foam.finiteVolume import setRefCell
pRefCell, pRefValue = setRefCell( p, mesh.solutionDict().subDict( word( "SIMPLE" ) ), pRefCell, pRefValue )
from Foam.OpenFOAM import dimensionedScalar
pMin = dimensionedScalar( mesh.solutionDict().subDict( word( "SIMPLE" ) ).lookup( word( "pMin" ) ) )
ext_Info() << "Creating turbulence model\n" << nl
from Foam import compressible
turbulence = compressible.RASModel.New( rho,
U,
phi,
thermo() )
from Foam.OpenFOAM import dimensionedScalar
from Foam import fvc
initialMass = fvc.domainIntegrate( rho )
return thermo, rho, p, h, psi, U, phi, pRefCell, pRefValue, turbulence, initialMass, pMin
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 __mapVolField__( theSourceField, meshToMeshInterp, patchMap, cuttingPatches ) :
aTargetField = None
meshTarget = meshToMeshInterp.toMesh()
aFieldName = theSourceField.name()
aFieldClass = getFieldClass( theSourceField )
if aFieldClass.ext_foundObject( meshTarget, aFieldName ) :
aTargetField = aFieldClass.ext_lookupObject( meshTarget, aFieldName )
else:
from Foam.OpenFOAM import IOobject, fileName
aTargetIOobject = IOobject( aFieldName,
fileName( meshTarget.time().timeName() ),
meshTarget,
IOobject.READ_IF_PRESENT,
IOobject.AUTO_WRITE )
if aTargetIOobject.headerOk() :
aTargetField = aFieldClass( aTargetIOobject, meshTarget )
pass
pass
from Foam import fvc
meshSource = meshToMeshInterp.fromMesh()
ext_Info() << tab <<"interpolating \"" << aFieldName << "\"" << nl
ext_Info() << tab << tab << "source : \"" << meshSource.time().path() << "\"" << nl
ext_Info() << tab << tab << tab << fvc.domainIntegrate( theSourceField ) << nl
ext_Info() << tab << tab << tab << theSourceField.ext_min() << nl
ext_Info() << tab << tab << tab << theSourceField.ext_max() << nl
from Foam.sampling import meshToMesh
meshToMeshInterp.interpolate( aTargetField, theSourceField, meshToMesh.INTERPOLATE )
ext_Info() << tab << tab << "target : \"" << meshTarget.time().path() << "\"" << nl
ext_Info() << tab << tab << tab << fvc.domainIntegrate( aTargetField ) << nl
ext_Info() << tab << tab << tab << aTargetField.ext_min() << nl
ext_Info() << tab << tab << tab << aTargetField.ext_max() << nl
return aTargetField
def _createFields( runTime, mesh ):
from Foam.OpenFOAM import ext_Info, nl
ext_Info() << "Reading thermophysical properties\n" << nl
from Foam.thermophysicalModels import basicPsiThermo
thermo = basicPsiThermo.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.RASModel.New( rho, U, phi, thermo() )
thermo.correct()
pRefCell = 0
pRefValue = 0.0
from Foam.finiteVolume import setRefCell
pRefCell, pRefValue = setRefCell( p, mesh.solutionDict().subDict( word( "SIMPLE" ) ), pRefCell, pRefValue )
from Foam import fvc
initialMass = fvc.domainIntegrate(rho)
return thermo, rho, p, h, psi, U, phi, turbulence, initialMass, pRefCell, pRefValue
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 _pEqn( runTime,mesh, UEqn, rho, thermo, psi, U, p, phi, pMin, nNonOrthCorr, \
pRefCell, pRefValue, eqnResidual, maxResidual, cumulativeContErr, transonic ):
rho.ext_assign(thermo.rho())
rUA = 1.0 / UEqn.A()
U.ext_assign(rUA * UEqn.H())
UEqn.clear()
closedVolume = False
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()))
for nonOrth in range(nNonOrthCorr + 1):
pEqn = fvm.div(phid, p) - fvm.laplacian(rho * rUA, p)
# Relax the pressure equation to ensure diagonal-dominance
pEqn.relax(mesh.relaxationFactor(word("pEqn")))
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 == pEqn.flux()
pass
pass
pass
else:
phi.ext_assign(
fvc.interpolate(rho) * ((fvc.interpolate(U) & mesh.Sf())))
from Foam.finiteVolume import adjustPhi
closedVolume = adjustPhi(phi, U, p)
for nonOrth in range(nNonOrthCorr + 1):
# Pressure corrector
pEqn = fvm.laplacian(rho * rUA, 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
pass
from Foam.finiteVolume.cfdTools.incompressible import continuityErrs
cumulativeContErr = continuityErrs(mesh, phi, runTime, 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 bound
bound(p, pMin)
# 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))
pass
return eqnResidual, maxResidual, cumulativeContErr
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 fun_pEqn( thermo, g, rho, UEqn, p, p_rgh, U, psi, phi, ghf, gh, initialMass, runTime, mesh, nNonOrthCorr, pRefCell, eqnResidual, maxResidual, cumulativeContErr ):
rho.ext_assign( thermo.rho() )
rho.relax()
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_rgh );
buoyancyPhi =surfaceScalarField( rhorUAf * ghf * fvc.snGrad( rho ) * mesh.magSf() )
phi.ext_assign( phi - buoyancyPhi )
for nonOrth in range( nNonOrthCorr+1 ):
from Foam import fvm
p_rghEqn = fvm.laplacian(rhorUAf, p_rgh) == fvc.div(phi)
from Foam.finiteVolume import getRefCellValue
p_rghEqn.setReference(pRefCell, getRefCellValue( p_rgh, pRefCell ) )
eqnResidual = p_rghEqn.solve().initialResidual()
if (nonOrth == 0):
maxResidual = max(eqnResidual, maxResidual)
pass
if (nonOrth == nNonOrthCorr):
# Calculate the conservative fluxes
phi.ext_assign( phi - p_rghEqn.flux() )
# Explicitly relax pressure for momentum corrector
p_rgh.relax()
U.ext_assign( U - rUA * fvc.reconstruct( ( buoyancyPhi + p_rghEqn.flux() ) / rhorUAf ) )
U.correctBoundaryConditions()
pass
from Foam.finiteVolume.cfdTools.general.include import ContinuityErrs
cumulativeContErr = ContinuityErrs( phi, runTime, mesh, cumulativeContErr )
p.ext_assign( p_rgh + rho * gh )
# For closed-volume cases adjust the pressure level
# to obey overall mass continuity
if closedVolume:
p.ext_assign( p + (initialMass - fvc.domainIntegrate( psi * p ) ) / fvc.domainIntegrate( psi ) )
p_rgh.ext_assign( p - rho * gh )
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 fun_pEqn(thermo, g, rho, UEqn, p, p_rgh, U, psi, phi, ghf, gh, initialMass,
runTime, mesh, nNonOrthCorr, pRefCell, eqnResidual, maxResidual,
cumulativeContErr):
rho.ext_assign(thermo.rho())
rho.relax()
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_rgh)
buoyancyPhi = surfaceScalarField(rhorUAf * ghf * fvc.snGrad(rho) *
mesh.magSf())
phi.ext_assign(phi - buoyancyPhi)
for nonOrth in range(nNonOrthCorr + 1):
from Foam import fvm
p_rghEqn = fvm.laplacian(rhorUAf, p_rgh) == fvc.div(phi)
from Foam.finiteVolume import getRefCellValue
p_rghEqn.setReference(pRefCell, getRefCellValue(p_rgh, pRefCell))
eqnResidual = p_rghEqn.solve().initialResidual()
if (nonOrth == 0):
maxResidual = max(eqnResidual, maxResidual)
pass
if (nonOrth == nNonOrthCorr):
# Calculate the conservative fluxes
phi.ext_assign(phi - p_rghEqn.flux())
# Explicitly relax pressure for momentum corrector
p_rgh.relax()
U.ext_assign(U - rUA * fvc.reconstruct(
(buoyancyPhi + p_rghEqn.flux()) / rhorUAf))
U.correctBoundaryConditions()
pass
from Foam.finiteVolume.cfdTools.general.include import ContinuityErrs
cumulativeContErr = ContinuityErrs(phi, runTime, mesh, cumulativeContErr)
p.ext_assign(p_rgh + rho * gh)
# For closed-volume cases adjust the pressure level
# to obey overall mass continuity
if closedVolume:
p.ext_assign(p + (initialMass - fvc.domainIntegrate(psi * p)) /
fvc.domainIntegrate(psi))
p_rgh.ext_assign(p - rho * gh)
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 _createFields(runTime, mesh):
from Foam.OpenFOAM import ext_Info, nl
ext_Info() << "Reading thermophysical properties\n" << nl
from Foam.thermophysicalModels import basicThermo, autoPtr_basicThermo
thermo = basicThermo.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.READ_IF_PRESENT, IOobject.AUTO_WRITE), thermo.rho())
p = thermo.p()
h = thermo.h()
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)
pRefCell = 0
pRefValue = 0.0
from Foam.finiteVolume import setRefCell
pRefCell, pRefValue = setRefCell(
p,
mesh.solutionDict().subDict(word("SIMPLE")), pRefCell, pRefValue)
from Foam.OpenFOAM import dimensionedScalar
pMin = dimensionedScalar(mesh.solutionDict().subDict(
word("SIMPLE")).lookup(word("pMin")))
ext_Info() << "Creating turbulence model\n" << nl
from Foam import compressible
turbulence = compressible.RASModel.New(rho, U, phi, thermo())
from Foam import fvc
initialMass = fvc.domainIntegrate(rho)
from Foam.finiteVolume import porousZones
pZones = porousZones(mesh)
from Foam.OpenFOAM import Switch
pressureImplicitPorosity = Switch(False)
nUCorr = 0
if pZones.size():
# nUCorrectors for pressureImplicitPorosity
if (mesh.solutionDict().subDict(word("SIMPLE")).found(
word("nUCorrectors"))):
from Foam.OpenFOAM import readInt
nUCorr = readInt(mesh.solutionDict().subDict(
word("SIMPLE")).lookup(word("nUCorrectors")))
pass
if nUCorr > 0:
pressureImplicitPorosity = True
pass
pass
return turbulence, p, h, rho, U, phi, thermo, pZones, pMin, pressureImplicitPorosity, initialMass, nUCorr, pRefCell, pRefValue
def _createFields(runTime, mesh):
from Foam.OpenFOAM import ext_Info, nl
ext_Info() << "Reading thermophysical properties\n" << nl
from Foam.thermophysicalModels import basicThermo, autoPtr_basicThermo
thermo = basicThermo.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.READ_IF_PRESENT, IOobject.AUTO_WRITE),
thermo.rho(),
)
p = thermo.p()
h = thermo.h()
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)
pRefCell = 0
pRefValue = 0.0
from Foam.finiteVolume import setRefCell
pRefCell, pRefValue = setRefCell(p, mesh.solutionDict().subDict(word("SIMPLE")), pRefCell, pRefValue)
from Foam.OpenFOAM import dimensionedScalar
pMin = dimensionedScalar(mesh.solutionDict().subDict(word("SIMPLE")).lookup(word("pMin")))
# ext_Info() << "Creating turbulence model\n" << nl
# from Foam import compressible
# turbulence = compressible.turbulenceModel.New( rho, U, phi, thermo() )
from Foam import fvc
initialMass = fvc.domainIntegrate(rho)
from Foam.finiteVolume import porousZones
pZones = porousZones(mesh)
from Foam.OpenFOAM import Switch
pressureImplicitPorousity = Switch(False)
nUCorr = 0
if pZones.size():
mesh.solutionDict().subDict(word("SIMPLE")).lookup(
word("pressureImplicitPorousity")
) >> pressureImplicitPorousity
pass
return p, h, rho, U, phi, thermo, pZones, pMin, pressureImplicitPorousity, initialMass, nUCorr, pRefCell, pRefValue
def _pEqn(
mesh,
rho,
thermo,
p,
U,
trTU,
trAU,
UEqn,
phi,
runTime,
pMin,
pressureImplicitPorousity,
nNonOrthCorr,
eqnResidual,
maxResidual,
cumulativeContErr,
initialMass,
pRefCell,
pRefValue,
):
if pressureImplicitPorousity:
U.ext_assign(trTU & UEqn.H())
else:
U.ext_assign(trAU * UEqn.H())
pass
UEqn.clear()
from Foam import fvc, fvm
phi.ext_assign(fvc.interpolate(rho * U) & mesh.Sf())
from Foam.finiteVolume import adjustPhi
closedVolume = adjustPhi(phi, U, p)
for nonOrth in range(nNonOrthCorr + 1):
tpEqn = None
if pressureImplicitPorosity:
tpEqn = fvm.laplacian(rho * trTU, p) == fvc.div(phi)
else:
tpEqn = fvm.laplacian(rho * trAU, p) == fvc.div(phi)
pass
tpEqn.setReference(pRefCell, pRefValue)
# retain the residual from the first iteration
tpEqn.solve()
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 pressureImplicitPorousity:
U.ext_assign(U - (trTU & fvc.grad(p)))
else:
U.ext_assign(U - (trAU * fvc.grad(p)))
pass
U.correctBoundaryConditions()
from Foam.finiteVolume import bound
bound(p, pMin)
# 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()))
pass
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
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 createFields( runTime, mesh, g ):
ext_Info() << "Reading thermophysical properties\n" << nl
from Foam.thermophysicalModels import autoPtr_basicPsiThermo, basicPsiThermo
thermo = basicPsiThermo.New(mesh)
from Foam.finiteVolume import volScalarField
from Foam.OpenFOAM import IOobject, word, fileName
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.RASModel.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 )
pRefCell = 0
pRefValue = 0.0
from Foam.finiteVolume import setRefCell
pRefCell, pRefValue = setRefCell( p, p_rgh, mesh.solutionDict().subDict( word( "SIMPLE" ) ), pRefCell, pRefValue )
from Foam import fvc
initialMass = fvc.domainIntegrate( rho )
totalVolume = mesh.V().ext_sum()
return thermo, rho, p, h, psi, U, phi, turbulence, gh, ghf, p_rgh, pRefCell, pRefValue, initialMass, totalVolume
def _pEqn( runTime,mesh, UEqn, rho, thermo, psi, U, p, phi, pMin, nNonOrthCorr, \
pRefCell, pRefValue, eqnResidual, maxResidual, cumulativeContErr, transonic ):
rho.ext_assign( thermo.rho() )
rUA = 1.0 / UEqn.A()
U.ext_assign( rUA * UEqn.H() )
UEqn.clear()
closedVolume = False
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() ) )
for nonOrth in range( nNonOrthCorr + 1 ) :
pEqn = fvm.div( phid, p ) - fvm.laplacian( rho * rUA, p )
# Relax the pressure equation to ensure diagonal-dominance
pEqn.relax( mesh.relaxationFactor( word( "pEqn" ) ) )
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 == pEqn.flux()
pass
pass
pass
else:
phi.ext_assign( fvc.interpolate( rho ) * ( ( fvc.interpolate(U) & mesh.Sf() ) ) )
from Foam.finiteVolume import adjustPhi
closedVolume = adjustPhi( phi, U, p )
for nonOrth in range( nNonOrthCorr + 1 ) :
# Pressure corrector
pEqn = fvm.laplacian( rho * rUA, 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
pass
from Foam.finiteVolume.cfdTools.incompressible import continuityErrs
cumulativeContErr = continuityErrs( mesh, phi, runTime, 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 bound
bound(p, pMin);
# 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 ) )
pass
return eqnResidual, maxResidual, cumulativeContErr
def pEqn( runTime, mesh, p, phi, psi, U, UEqn, g, rho, thermo, initialMass, eqnResidual, maxResidual, nNonOrthCorr, cumulativeContErr, pRefCell, pRefValue ):
rho.ext_assign( thermo.rho() )
from Foam import fvc
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() )
UEqn.clear();
phi.ext_assign( fvc.interpolate( rho ) * ( fvc.interpolate( U ) & mesh.Sf() ) )
from Foam.finiteVolume import adjustPhi
closedVolume = adjustPhi( phi, U, p )
buoyancyPhi = rhorUAf * fvc.interpolate( rho ) * (g & mesh.Sf() )
phi.ext_assign( phi + buoyancyPhi )
from Foam import fvm
for nonOrth in range( nNonOrthCorr + 1):
pEqn = fvm.laplacian( rhorUAf, 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:
# 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 ) )
pass
# 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() ) / rhorUAf ) )
U.correctBoundaryConditions()
pass
from Foam.finiteVolume.cfdTools.incompressible import continuityErrs
cumulativeContErr = continuityErrs( mesh, phi, runTime, cumulativeContErr )
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 _pEqn( mesh, rho, thermo, p, U, trTU, trAU, UEqn, phi, \
runTime, pMin, pressureImplicitPorosity, nNonOrthCorr, eqnResidual, maxResidual, cumulativeContErr, initialMass, pRefCell, pRefValue ):
if pressureImplicitPorosity:
U.ext_assign(trTU & UEqn.H())
else:
U.ext_assign(trAU * UEqn.H())
pass
UEqn.clear()
from Foam import fvc, fvm
phi.ext_assign(fvc.interpolate(rho * U) & mesh.Sf())
from Foam.finiteVolume import adjustPhi
closedVolume = adjustPhi(phi, U, p)
for nonOrth in range(nNonOrthCorr + 1):
tpEqn = None
if pressureImplicitPorosity:
tpEqn = (fvm.laplacian(rho * trTU, p) == fvc.div(phi))
else:
tpEqn = (fvm.laplacian(rho * 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)
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()
from Foam.finiteVolume import bound
bound(p, pMin)
# 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()))
pass
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
def createFields( runTime, mesh, g ):
ext_Info() << "Reading thermophysical properties\n" << nl
from Foam.thermophysicalModels import autoPtr_basicThermo, basicThermo
thermo = basicThermo.New( mesh )
from Foam.finiteVolume import volScalarField
from Foam.OpenFOAM import IOobject, word, fileName
rho = volScalarField( IOobject( word( "rho" ),
fileName( runTime.timeName() ),
mesh,
IOobject.NO_READ,
IOobject.NO_WRITE),
thermo.rho() )
p = thermo.p()
h = thermo.h()
T = thermo.T()
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.RASModel.New( rho, U, phi, thermo() )
ext_Info() << "Calculating field g.h\n" << nl
gh = volScalarField ( word( "gh" ), g & mesh.C() )
from Foam.OpenFOAM import dimensionedScalar
pRef = dimensionedScalar( word( "pRef" ), p.dimensions(), thermo.lookup( word( "pRef" ) ) )
ext_Info() << "Creating field pd\n" << nl
pd = volScalarField( IOobject( word( "pd" ),
fileName( runTime.timeName() ),
mesh,
IOobject.MUST_READ,
IOobject.AUTO_WRITE ),
mesh )
p.ext_assign( pd + rho * gh + pRef )
thermo.correct()
pdRefCell = 0
pdRefValue = 0.0
from Foam.finiteVolume import setRefCell
pRefCell, pRefValue = setRefCell( pd, mesh.solutionDict().subDict( word( "SIMPLE" ) ), pdRefCell, pdRefValue )
ext_Info() << "Creating radiation model\n" << nl
from Foam.radiation import radiationModel
radiation =radiationModel.New( T )
from Foam import fvc
initialMass = fvc.domainIntegrate( rho )
return thermo, rho, p, h, T, U, phi, turbulence, gh, pRef, pd, p, pdRefCell, pdRefValue, radiation, initialMass
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_basicRhoThermo
thermoFluid = PtrList_basicRhoThermo( 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_basicRhoThermo, basicRhoThermo
thermo= basicRhoThermo.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
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()
initialMassf[ index ] = fvc.domainIntegrate( rhof[ index ] ).value()
return pdf, thermof, rhof, Kf, Uf, phif, turb, DpDtf, ghf, initialMassf, pRef
#-----------------------------------------------------------------------------------------------------------------------
def compressibleCourantNo( mesh, runTime, rho, phi) :
from Foam.OpenFOAM import Time
from Foam.finiteVolume import fvMesh
from Foam.finiteVolume import surfaceScalarField
CoNum = 0.0;
meanCoNum = 0.0;
