def _createFields(runTime, mesh):
ref.ext_Info() << "Reading field U\n" << ref.nl
U = man.volVectorField(
man.IOobject(ref.word("U"), ref.fileName(runTime.timeName()), mesh,
ref.IOobject.MUST_READ, ref.IOobject.AUTO_WRITE), mesh)
ref.ext_Info() << "Creating face flux\n" << ref.nl
phi = man.surfaceScalarField(
man.IOobject(ref.word("phi"), ref.fileName(runTime.timeName()), mesh,
ref.IOobject.NO_READ, ref.IOobject.NO_WRITE), mesh,
ref.dimensionedScalar(ref.word("zero"),
mesh.Sf().dimensions() * U.dimensions(), 0.0))
laminarTransport = man.singlePhaseTransportModel(U, phi)
turbulence = man.incompressible.RASModel.New(U, phi, laminarTransport)
transportProperties = man.IOdictionary(
man.IOobject(ref.word("transportProperties"),
ref.fileName(runTime.constant()), mesh,
ref.IOobject.MUST_READ, ref.IOobject.NO_WRITE))
Ubar = ref.dimensionedVector(transportProperties.lookup(ref.word("Ubar")))
flowDirection = (Ubar / Ubar.mag()).ext_value()
flowMask = flowDirection.sqr()
gradP = ref.dimensionedVector(ref.word("gradP"),
ref.dimensionSet(0.0, 1.0, -2.0, 0.0, 0.0),
ref.vector(0.0, 0.0, 0.0))
return U, phi, laminarTransport, turbulence, Ubar, gradP, flowDirection, flowMask
def readGravitationalAcceleration(runTime, mesh):
ref.ext_Info() << "\nReading g" << ref.nl
g = ref.uniformDimensionedVectorField(
ref.IOobject(ref.word("g"), ref.fileName(runTime.constant()), mesh,
ref.IOobject.MUST_READ, ref.IOobject.NO_WRITE))
return g
def _createFields(runTime, mesh):
ref.ext_Info() << "Reading field p\n" << ref.nl
p = man.volScalarField(
man.IOobject(
ref.word("p"), ref.fileName(runTime.timeName()), mesh, ref.IOobject.MUST_READ, ref.IOobject.AUTO_WRITE
),
mesh,
)
ref.ext_Info() << "Reading field U\n" << ref.nl
U = man.volVectorField(
man.IOobject(
ref.word("U"), ref.fileName(runTime.timeName()), mesh, ref.IOobject.MUST_READ, ref.IOobject.AUTO_WRITE
),
mesh,
)
phi = man.createPhi(runTime, mesh, U)
pRefCell = 0
pRefValue = 0.0
pRefCell, pRefValue = ref.setRefCell(p, mesh.solutionDict().subDict(ref.word("PISO")), pRefCell, pRefValue)
laminarTransport = man.singlePhaseTransportModel(U, phi)
turbulence = man.incompressible.turbulenceModel.New(U, phi, laminarTransport)
return p, U, phi, turbulence, pRefCell, pRefValue, laminarTransport
def _createFields(runTime, mesh, potentialFlow, args):
ref.ext_Info() << "Reading field p\n" << ref.nl
p = man.volScalarField(
man.IOobject(ref.word("p"), ref.fileName(runTime.timeName()), mesh,
ref.IOobject.MUST_READ, ref.IOobject.NO_WRITE), mesh)
p << ref.dimensionedScalar(ref.word("zero"), p.dimensions(), 0.0)
ref.ext_Info() << "Reading field U\n" << ref.nl
U = man.volVectorField(
man.IOobject(ref.word("U"), ref.fileName(runTime.timeName()), mesh,
ref.IOobject.MUST_READ, ref.IOobject.AUTO_WRITE), mesh)
U << ref.dimensionedVector(ref.word("0"), U.dimensions(), ref.vector.zero)
phi = man.surfaceScalarField(
man.IOobject(ref.word("phi"), ref.fileName(runTime.timeName()), mesh,
ref.IOobject.NO_READ, ref.IOobject.AUTO_WRITE),
man.fvc.interpolate(U)
& man.surfaceVectorField(mesh.Sf(), man.Deps(mesh)))
if args.optionFound(ref.word("initialiseUBCs")):
U.correctBoundaryConditions()
phi << (ref.fvc.interpolate(U) & mesh.Sf())
pass
pRefCell = 0
pRefValue = 0.0
pRefCell, pRefValue = ref.setRefCell(p, potentialFlow, pRefCell, pRefValue)
return p, U, phi, pRefCell, pRefValue
def fun_pEqn( mesh, runTime, pimple, thermo, rho, p, h, psi, U, phi, mrfZones, turbulence, UEqn, dpdt, K, cumulativeContErr, rhoMax, rhoMin ):
rho << thermo.rho()
rho << rho().ext_max( rhoMin )
rho << rho().ext_min( rhoMax )
rho.relax()
rAU = 1.0 / UEqn.A()
U << rAU() * UEqn.H()
if pimple.transonic():
phid = ref.surfaceScalarField( ref.word( "phid" ), ref.fvc.interpolate( psi ) * ( ( ref.fvc.interpolate( U ) & mesh.Sf() ) \
+ ref.fvc.ddtPhiCorr( rAU, rho, U, phi ) ) );
mrfZones.relativeFlux( ref.fvc.interpolate( psi ), phid )
while pimple.correctNonOrthogonal():
pEqn = ref.fvm.ddt( psi, p) + ref.fvm.div( phid, p ) - ref.fvm.laplacian( rho() * rAU, p ) # mixed calculations
pEqn.solve( mesh.solver( p.select( pimple.finalInnerIter() ) ) )
if pimple.finalNonOrthogonalIter():
phi == pEqn.flux()
pass
pass
pass
else:
phi << ref.fvc.interpolate( rho ) * ( ( ref.fvc.interpolate( U ) & mesh.Sf() ) + ref.fvc.ddtPhiCorr( rAU, rho, U, phi ) )
mrfZones.relativeFlux( ref.fvc.interpolate( rho ), phi )
while pimple.correctNonOrthogonal():
pEqn = ref.fvm.ddt( psi, p ) + ref.fvc.div( phi ) - ref.fvm.laplacian( rho()*rAU, p ) # mixed calculations
pEqn.solve( mesh.solver( p.select( pimple.finalInnerIter() ) ) )
if pimple.finalNonOrthogonalIter():
phi += pEqn.flux()
pass
pass
pass
ref.rhoEqn( rho, phi )
cumulativeContErr = ref.compressibleContinuityErrs( rho(), thermo, cumulativeContErr ) # mixed calculations
# Explicitly relax pressure for momentum corrector
p.relax()
# Recalculate density from the relaxed pressure
rho << thermo.rho()
rho << rho().ext_max( rhoMin )
rho << rho().ext_min( rhoMax )
rho.relax()
ref.ext_Info()<< "rho max/min : " << rho.ext_max().value() << " " << rho.ext_min().value() << ref.nl
U -= rAU * ref.fvc.grad( p )
U.correctBoundaryConditions()
K << 0.5 * U.magSqr()
dpdt << ref.fvc.ddt( p )
return cumulativeContErr
def _createFields( runTime, mesh ):
ref.ext_Info() << "Reading field p\n" << ref.nl
p = man.volScalarField( man.IOobject( ref.word( "p" ),
ref.fileName( runTime.timeName() ),
mesh,
ref.IOobject.MUST_READ,
ref.IOobject.AUTO_WRITE ),
mesh )
ref.ext_Info() << "Reading field U\n" << ref.nl
U = man.volVectorField( man.IOobject( ref.word( "U" ),
ref.fileName( runTime.timeName() ),
mesh,
ref.IOobject.MUST_READ,
ref.IOobject.AUTO_WRITE ),
mesh )
phi = man.createPhi( runTime, mesh, U )
fluid = man.singlePhaseTransportModel( U, phi )
pRefCell = 0
pRefValue = 0.0
pRefCell, pRefValue = ref.setRefCell( p, mesh.solutionDict().subDict( ref.word( "PISO" ) ), pRefCell, pRefValue )
return p, U, phi, fluid, pRefCell, pRefValue
def _createFields(runTime, mesh, potentialFlow):
ref.ext_Info() << "Reading field p\n" << ref.nl
p = man.volScalarField(
man.IOobject(
ref.word("p"), ref.fileName(runTime.timeName()), mesh, ref.IOobject.MUST_READ, ref.IOobject.NO_WRITE
),
mesh,
)
p << ref.dimensionedScalar(ref.word("zero"), p.dimensions(), 0.0)
ref.ext_Info() << "Reading field U\n" << ref.nl
U = man.volVectorField(
man.IOobject(
ref.word("U"), ref.fileName(runTime.timeName()), mesh, ref.IOobject.MUST_READ, ref.IOobject.AUTO_WRITE
),
mesh,
)
U << ref.dimensionedVector(ref.word("0"), U.dimensions(), ref.vector.zero)
phi = man.surfaceScalarField(
man.IOobject(
ref.word("phi"), ref.fileName(runTime.timeName()), mesh, ref.IOobject.NO_READ, ref.IOobject.AUTO_WRITE
),
man.fvc.interpolate(U) & man.surfaceVectorField(mesh.Sf(), man.Deps(mesh)),
)
pRefCell = 0
pRefValue = 0.0
pRefCell, pRefValue = ref.setRefCell(p, potentialFlow, pRefCell, pRefValue)
return p, U, phi, pRefCell, pRefValue
def CourantNo(runTime, mesh, h, phi, magg):
CoNum = 0.0
meanCoNum = 0.0
waveCoNum = 0.0
if mesh.nInternalFaces():
phi_mag = ref.fvc.surfaceSum(phi.mag())
sumPhi = phi_mag.internalField() / h.internalField()
V = mesh.V()
CoNum = 0.5 * (sumPhi / V.field()).gMax() * runTime.deltaTValue()
V_field = V.field()
meanCoNum = 0.5 * (sumPhi.gSum() /
V_field.gSum()) * runTime.deltaTValue()
# Gravity wave Courant number
waveCoNum = 0.25 * (
ref.fvc.surfaceSum(
ref.fvc.interpolate(h.sqrt()) * mesh.magSf()).internalField() /
V.field()).gMax() * magg.sqrt().value() * runTime.deltaTValue()
pass
ref.ext_Info(
) << "Courant number mean: " << meanCoNum << " max: " << CoNum << ref.nl
ref.ext_Info(
) << "Gravity wave Courant number max: " << waveCoNum << ref.nl
return CoNum, meanCoNum, waveCoNum
def readGravitationalAcceleration(runTime, mesh):
ref.ext_Info() << "\nReading gravitationalProperties" << ref.nl
gravitationalProperties = man.IOdictionary(
man.IOobject(
ref.word("gravitationalProperties"),
ref.fileName(runTime.constant()),
mesh,
ref.IOobject.MUST_READ_IF_MODIFIED,
ref.IOobject.NO_WRITE,
)
)
g = ref.dimensionedVector(gravitationalProperties.lookup(ref.word("g")))
rotating = ref.Switch(gravitationalProperties.lookup(ref.word("rotating")))
if rotating:
Omega = ref.dimensionedVector(gravitationalProperties.lookup(ref.word("Omega")))
else:
Omega = ref.dimensionedVector(ref.word("Omega"), -ref.dimTime, ref.vector(0, 0, 0))
magg = g.mag()
gHat = g / magg
return gravitationalProperties, g, rotating, Omega, magg, gHat
def createFields( runTime, mesh, rhoO, psi ):
ref.ext_Info()<< "Reading field p\n" << ref.nl
p = man.volScalarField( man.IOobject( ref.word( "p" ),
ref.fileName( runTime.timeName() ),
mesh,
ref.IOobject.MUST_READ,
ref.IOobject.AUTO_WRITE ),
mesh )
ref.ext_Info()<< "Reading field U\n" << ref.nl
U = man.volVectorField( man.IOobject( ref.word( "U" ),
ref.fileName( runTime.timeName() ),
mesh,
ref.IOobject.MUST_READ,
ref.IOobject.AUTO_WRITE ),
mesh )
rho = man.volScalarField( man.IOobject( ref.word( "rho" ),
ref.fileName( runTime.timeName() ),
mesh,
ref.IOobject.NO_READ,
ref.IOobject.AUTO_WRITE ),
rhoO + psi * p )
phi = man.compressibleCreatePhi( runTime, mesh, U, rho )
return p, U, rho, phi
def fun_pEqn( mesh, runTime, simple, thermo, rho, p, h, psi, U, phi, turbulence, \
gh, ghf, p_rgh, UEqn, pRefCell, pRefValue, cumulativeContErr, initialMass):
rho << thermo.rho()
rho.relax()
rAU = 1.0 / UEqn.A()
rhorAUf = ref.surfaceScalarField(ref.word("(rho*(1|A(U)))"),
ref.fvc.interpolate(rho() * rAU))
U << rAU * UEqn.H()
phi << ref.fvc.interpolate(rho) * (ref.fvc.interpolate(U()) & mesh.Sf())
closedVolume = ref.adjustPhi(phi, U, p_rgh)
buoyancyPhi = rhorAUf * ghf * ref.fvc.snGrad(rho) * mesh.magSf()
phi -= buoyancyPhi
while simple.correctNonOrthogonal():
p_rghEqn = (ref.fvm.laplacian(rhorAUf, p_rgh) == ref.fvc.div(phi))
p_rghEqn.setReference(pRefCell, ref.getRefCellValue(p_rgh, pRefCell))
p_rghEqn.solve()
if simple.finalNonOrthogonalIter():
# Calculate the conservative fluxes
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 -= rAU * ref.fvc.reconstruct(
(buoyancyPhi + p_rghEqn.flux()) / rhorAUf)
U.correctBoundaryConditions()
pass
pass
cumulativeContErr = ref.ContinuityErrs(phi, runTime, mesh,
cumulativeContErr)
p << p_rgh + rho * gh
# For closed-volume cases adjust the pressure level
# to obey overall mass continuity
if closedVolume:
p += (initialMass -
ref.fvc.domainIntegrate(psi * p)) / ref.fvc.domainIntegrate(psi)
p_rgh << p - rho * gh
pass
rho << thermo.rho()
rho.relax()
ref.ext_Info() << "rho max/min : " << rho.ext_max().value(
) << " " << rho.ext_min().value() << ref.nl
return cumulativeContErr
def _createFields(runTime, mesh):
ref.ext_Info() << "Reading field p\n" << ref.nl
p = man.volScalarField(
man.IOobject(ref.word("p"), ref.fileName(runTime.timeName()), mesh,
ref.IOobject.MUST_READ, ref.IOobject.AUTO_WRITE), mesh)
ref.ext_Info() << "Reading field U\n" << ref.nl
U = man.volVectorField(
man.IOobject(ref.word("U"), ref.fileName(runTime.timeName()), mesh,
ref.IOobject.MUST_READ, ref.IOobject.AUTO_WRITE), mesh)
phi = man.createPhi(runTime, mesh, U)
pRefCell = 0
pRefValue = 0.0
pRefCell, pRefValue = ref.setRefCell(
p,
mesh.solutionDict().subDict(ref.word("PIMPLE")), pRefCell, pRefValue)
laminarTransport = man.singlePhaseTransportModel(U, phi)
turbulence = man.incompressible.turbulenceModel.New(
U, phi, laminarTransport)
return p, U, phi, turbulence, pRefCell, pRefValue, laminarTransport
def createFields(runTime, mesh, pimple):
ref.ext_Info() << "Reading thermophysical properties\n" << ref.nl
pThermo = man.basicPsiThermo.New(mesh)
p = man.volScalarField(pThermo.p(), man.Deps(pThermo))
h = man.volScalarField(pThermo.h(), man.Deps(pThermo))
psi = man.volScalarField(pThermo.psi(), man.Deps(pThermo))
rho = man.volScalarField(
man.IOobject(ref.word("rho"), ref.fileName(runTime.timeName()), mesh,
ref.IOobject.READ_IF_PRESENT, ref.IOobject.AUTO_WRITE),
man.volScalarField(pThermo.rho(), man.Deps(pThermo)))
ref.ext_Info() << "Reading field U\n" << ref.nl
U = man.volVectorField(
man.IOobject(ref.word("U"), ref.fileName(runTime.timeName()), mesh,
ref.IOobject.MUST_READ, ref.IOobject.AUTO_WRITE), mesh)
phi = man.compressibleCreatePhi(runTime, mesh, U, rho)
rhoMax = ref.dimensionedScalar(pimple.dict().lookup(ref.word("rhoMax")))
rhoMin = ref.dimensionedScalar(pimple.dict().lookup(ref.word("rhoMin")))
ref.ext_Info() << "Creating turbulence model\n" << ref.nl
turbulence = man.compressible.turbulenceModel.New(rho, U, phi, pThermo)
ref.ext_Info() << "Creating field dpdt\n" << ref.nl
dpdt = man.volScalarField(ref.word("dpdt"), man.fvc.ddt(p))
ref.ext_Info() << "Creating field kinetic energy K\n" << ref.nl
K = man.volScalarField(ref.word("K"),
man.volScalarField(0.5 * U.magSqr(), man.Deps(U)))
return pThermo, p, h, psi, rho, U, phi, rhoMax, rhoMin, turbulence, dpdt, K
def CourantNo(runTime, mesh, h, phi, magg):
CoNum = 0.0
meanCoNum = 0.0
waveCoNum = 0.0
if mesh.nInternalFaces():
phi_mag = ref.fvc.surfaceSum(phi.mag())
sumPhi = phi_mag.internalField() / h.internalField()
V = mesh.V()
CoNum = 0.5 * (sumPhi / V.field()).gMax() * runTime.deltaTValue()
V_field = V.field()
meanCoNum = 0.5 * (sumPhi.gSum() / V_field.gSum()) * runTime.deltaTValue()
# Gravity wave Courant number
waveCoNum = (
0.25
* (ref.fvc.surfaceSum(ref.fvc.interpolate(h.sqrt()) * mesh.magSf()).internalField() / V.field()).gMax()
* magg.sqrt().value()
* runTime.deltaTValue()
)
pass
ref.ext_Info() << "Courant number mean: " << meanCoNum << " max: " << CoNum << ref.nl
ref.ext_Info() << "Gravity wave Courant number max: " << waveCoNum << ref.nl
return CoNum, meanCoNum, waveCoNum
def fun_pEqn( mesh, runTime, pimple, thermo, rho, p, h, psi, U, phi, mrfZones, turbulence, UEqn, DpDt, cumulativeContErr, corr, rhoMax, rhoMin ):
rho << thermo.rho()
rho << rho().ext_max( rhoMin )
rho << rho().ext_min( rhoMax )
rho.relax()
rAU = 1.0 / UEqn.A()
U << rAU() * UEqn.H()
if pimple.transonic():
phid = ref.surfaceScalarField( ref.word( "phid" ), ref.fvc.interpolate( psi ) * ( ( ref.fvc.interpolate( U ) & mesh.Sf() ) \
+ ref.fvc.ddtPhiCorr( rAU, rho, U, phi ) ) );
mrfZones.relativeFlux( ref.fvc.interpolate( psi ), phid )
for nonOrth in range( pimple.nNonOrthCorr() + 1 ):
pEqn = ref.fvm.ddt( psi, p) + ref.fvm.div( phid, p ) - ref.fvm.laplacian( rho() * rAU, p ) # mixed calculations
pEqn.solve( mesh.solver( p.select( pimple.finalInnerIter( corr, nonOrth ) ) ) )
if nonOrth == pimple.nNonOrthCorr():
phi == pEqn.flux()
pass
pass
pass
else:
phi << ref.fvc.interpolate( rho ) * ( ( ref.fvc.interpolate( U ) & mesh.Sf() ) + ref.fvc.ddtPhiCorr( rAU, rho, U, phi ) )
mrfZones.relativeFlux( ref.fvc.interpolate( rho ), phi )
for nonOrth in range( pimple.nNonOrthCorr() + 1 ):
pEqn = ref.fvm.ddt( psi, p ) + ref.fvc.div( phi ) - ref.fvm.laplacian( rho()*rAU, p ) # mixed calculations
pEqn.solve( mesh.solver( p.select( pimple.finalInnerIter( corr, nonOrth ) ) ) )
if nonOrth == pimple.nNonOrthCorr():
phi += pEqn.flux()
pass
pass
pass
ref.rhoEqn( rho, phi )
cumulativeContErr = ref.compressibleContinuityErrs( rho(), thermo, cumulativeContErr ) # mixed calculations
# Explicitly relax pressure for momentum corrector
p.relax()
# Recalculate density from the relaxed pressure
rho << thermo.rho()
rho << rho().ext_max( rhoMin )
rho << rho().ext_min( rhoMax )
rho.relax()
ref.ext_Info()<< "rho max/min : " << rho.ext_max().value() << " " << rho.ext_min().value() << ref.nl
U -= rAU * ref.fvc.grad( p )
U.correctBoundaryConditions()
DpDt << ref.fvc.DDt( ref.surfaceScalarField( ref.word( "phiU" ), phi() / ref.fvc.interpolate( rho ) ), p ) # mixed calculations
return cumulativeContErr
def interrogateWallPatches( mesh ):
# Search for wall patches faces and store normals
faceId = -1
patchId = -1
nWallFaces = 0
wallNormal = ref.vector.zero
patches = mesh.boundary()
for patchi in range( patches.size() ):
currPatch = patches[ patchi ]
if ref.wallFvPatch.ext_isA( currPatch ):
nf = currPatch.nf()
for facei in range( nf.size() ):
nWallFaces = nWallFaces +1
if nWallFaces == 1:
wallNormal = -nf()[ facei ]
faceId = facei
patchId = patchi
pass
elif nWallFaces == 2:
wallNormal2 = -nf()[ facei ]
#- Check that wall faces are parallel
if ref.mag( wallNormal & wallNormal2 ) > 1.01 or ref.mag( wallNormal & wallNormal2 ) < 0.99:
ref.ext_Info() << "wall faces are not parallel for patches " << patches[ patchId ].name() << " and " \
<< currPatch.name() << nl
import os; os.abort()
pass
pass
else:
ref.ext_Info() << "number of wall faces > 2"<< nl
import os; os.abort()
pass
pass
pass
pass
if nWallFaces == 0:
ref.ext_Info() << "No wall patches identified"
import os; os.abort()
pass
else:
ref.ext_Info()<< "Generating wall data for patch: " << patches[ patchId ].name() << ref.nl
pass
pass
# store local id of near-walll cell to process
cellId = patches[ patchId ].faceCells()[ faceId ];
# create position array for graph generation
y = wallNormal & ( mesh.C().internalField() - mesh.C().ext_boundaryField()[ patchId ][ faceId ] )
ref.ext_Info() << " Height to first cell centre y0 = " << y[ cellId ] << ref.nl
return faceId, patchId, nWallFaces, wallNormal, cellId, y
def main_standalone( argc, argv ):
ref.argList.addBoolOption( ref.word( "writep" ), "write the final pressure field" )
ref.argList.addBoolOption( ref.word( "initialiseUBCs" ), "initialise U boundary conditions" )
args = ref.setRootCase( argc, argv )
runTime = man.createTime( args )
mesh = man.createMesh( runTime )
potentialFlow, nNonOrthCorr = readControls( mesh )
p, U, phi, pRefCell, pRefValue = _createFields( runTime, mesh, potentialFlow,args )
ref.ext_Info() << ref.nl << "Calculating potential flow" << ref.nl
# Since solver contains no time loop it would never execute
# function objects so do it ourselves.
runTime.functionObjects().start()
ref.adjustPhi(phi, U, p)
for nonOrth in range( nNonOrthCorr + 1):
pEqn = ( ref.fvm.laplacian( ref.dimensionedScalar( ref.word( "1" ), ref.dimTime / p.dimensions() * ref.dimensionSet( 0.0, 2.0, -2.0, 0.0, 0.0 ), 1.0 ), p )
== ref.fvc.div( phi ) )
pEqn.setReference( pRefCell, pRefValue )
pEqn.solve()
if nonOrth == nNonOrthCorr:
phi -= pEqn.flux()
pass
pass
ref.ext_Info() << "continuity error = " << ref.fvc.div( phi ).mag().weightedAverage( mesh.V() ).value() << ref.nl
U << ref.fvc.reconstruct( phi )
U.correctBoundaryConditions()
ref.ext_Info() << "Interpolated U error = " << ( ( ( ref.fvc.interpolate( U ) & mesh.Sf() ) - phi ).sqr().sum().sqrt() /mesh.magSf().sum() ).value() << ref.nl
# Force the write
U.write()
phi.write()
if args.optionFound( ref.word( "writep" ) ):
p.write()
pass
runTime.functionObjects().end()
ref.ext_Info() << "ExecutionTime = " << runTime.elapsedCpuTime() << " s" << \
" ClockTime = " << runTime.elapsedClockTime() << " s" << ref.nl << ref.nl
ref.ext_Info() << "End\n" << ref.nl
import os
return os.EX_OK
def fun_pEqn( mesh, runTime, simple, thermo, rho, p, h, psi, U, phi, turbulence, \
gh, ghf, p_rgh, UEqn, pRefCell, pRefValue, cumulativeContErr, initialMass):
rho << thermo.rho()
rho.relax()
rAU = 1.0 / UEqn.A()
rhorAUf = ref.surfaceScalarField( ref.word( "(rho*(1|A(U)))" ), ref.fvc.interpolate( rho() * rAU ) )
U << rAU * UEqn.H()
#UEqn.clear()
phi << ref.fvc.interpolate( rho ) * ( ref.fvc.interpolate( U() ) & mesh.Sf() )
closedVolume = ref.adjustPhi( phi, U, p_rgh )
buoyancyPhi = rhorAUf * ghf * ref.fvc.snGrad( rho ) * mesh.magSf()
phi -= buoyancyPhi
for nonOrth in range( simple.nNonOrthCorr() + 1 ):
p_rghEqn = ( ref.fvm.laplacian( rhorAUf, p_rgh ) == ref.fvc.div( phi ) )
p_rghEqn.setReference( pRefCell, ref.getRefCellValue( p_rgh, pRefCell ) )
p_rghEqn.solve()
if nonOrth == simple.nNonOrthCorr():
# Calculate the conservative fluxes
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 -= rAU * ref.fvc.reconstruct( ( buoyancyPhi + p_rghEqn.flux() ) / rhorAUf )
U.correctBoundaryConditions()
pass
pass
cumulativeContErr = ref.ContinuityErrs( phi, runTime, mesh, cumulativeContErr )
p << p_rgh + rho * gh
# For closed-volume cases adjust the pressure level
# to obey overall mass continuity
if closedVolume:
p += ( initialMass - ref.fvc.domainIntegrate( psi * p ) ) / ref.fvc.domainIntegrate( psi )
p_rgh << p - rho * gh
pass
rho << thermo.rho()
rho.relax()
ref.ext_Info() << "rho max/min : " << rho.ext_max().value() << " " << rho.ext_min().value() << ref.nl
return cumulativeContErr
def readGravitationalAcceleration( runTime, mesh ):
ref.ext_Info() << "\nReading g" << ref.nl
g= ref.uniformDimensionedVectorField( ref.IOobject( ref.word("g"),
ref.fileName( runTime.constant() ),
mesh,
ref.IOobject.MUST_READ,
ref.IOobject.NO_WRITE ) )
return g
def main_standalone(argc, argv):
args = ref.setRootCase(argc, argv)
runTime = man.createTime(args)
mesh = man.createMesh(runTime)
U, phi, laminarTransport, turbulence, Ubar, gradP, flowDirection, flowMask = _createFields(
runTime, mesh)
faceId, patchId, nWallFaces, wallNormal, cellId, y = interrogateWallPatches(
mesh)
ref.ext_Info() << "\nStarting time loop\n" << ref.nl
while runTime.loop():
ref.ext_Info() << "Time = " << runTime.timeName() << ref.nl << ref.nl
divR = turbulence.divDevReff(U)
divR.source() << (flowMask & divR.source())
UEqn = divR == gradP
UEqn.relax()
UEqn.solve()
# Correct driving force for a constant mass flow rate
UbarStar = flowMask & U.weightedAverage(mesh.V())
U += Ubar - UbarStar
gradP += (Ubar - UbarStar) / (1.0 / UEqn.A()).weightedAverage(mesh.V())
turbulence.correct()
ref.ext_Info() << "Uncorrected Ubar = " << ( flowDirection & UbarStar.value() ) << \
", pressure gradient = " << ( flowDirection & gradP.value() )<< ref.nl
evaluateNearWall(turbulence, U, y, faceId, patchId, nWallFaces,
wallNormal, cellId, flowDirection)
if runTime.outputTime():
makeGraphs(runTime, mesh, U, turbulence, faceId, patchId,
nWallFaces, wallNormal, cellId, flowDirection, y)
pass
ref.ext_Info() << "ExecutionTime = " << runTime.elapsedCpuTime() << " s" << \
" ClockTime = " << runTime.elapsedClockTime() << " s" << ref.nl << ref.nl
pass
ref.ext_Info() << "End\n" << ref.nl
import os
return os.EX_OK
def createDynamicFvMesh_020000( runTime ):
from Foam import ref
ref.ext_Info() << "Create mesh for time = " << runTime.timeName() << ref.nl << ref.nl
mesh = ref.dynamicFvMesh.New( ref.IOobject( ref.dynamicFvMesh.defaultRegion.fget(),
ref.fileName( runTime.timeName() ),
runTime,
ref.IOobject.MUST_READ ) )
return mesh
def setDeltaT(runTime, adjustTimeStep, maxCo, CoNum, maxAlphaCo, alphaCoNum, maxDeltaT):
if adjustTimeStep:
maxDeltaTFact = min(maxCo / (CoNum + ref.SMALL), maxAlphaCo / (alphaCoNum + ref.SMALL))
deltaTFact = min(min(maxDeltaTFact, 1.0 + 0.1 * maxDeltaTFact), 1.2)
runTime.setDeltaT(min(deltaTFact * runTime.deltaT().value(), maxDeltaT))
ref.ext_Info() << "deltaT = " << runTime.deltaT().value() << ref.nl
pass
return runTime
def createDynamicFvMesh_020000(runTime):
from Foam import ref
ref.ext_Info() << "Create mesh for time = " << runTime.timeName(
) << ref.nl << ref.nl
mesh = ref.dynamicFvMesh.New(
ref.IOobject(ref.dynamicFvMesh.defaultRegion.fget(),
ref.fileName(runTime.timeName()), runTime,
ref.IOobject.MUST_READ))
return mesh
def createPhia(runTime, mesh, Ua):
ref.ext_Info() << "Reading/calculating face flux field phia\n" << ref.nl
phia = man.surfaceScalarField(
man.IOobject(ref.word("phia"), ref.fileName(runTime.timeName()), mesh,
ref.IOobject.READ_IF_PRESENT, ref.IOobject.AUTO_WRITE),
man.surfaceScalarField(
ref.linearInterpolate(Ua) & mesh.Sf(), man.Deps(Ua, mesh)))
return phia
def solveSolid(mesh, kappa, T, nNonOrthCorr):
for index in range(nNonOrthCorr + 1):
TEqn = -ref.fvm.laplacian(kappa, T)
TEqn.relax()
TEqn.solve()
pass
ref.ext_Info() << "Min/max T:" << T.ext_min().value() << " " << T.ext_max().value() << ref.nl
pass
def adjointContinuityErrs(runTime, mesh, phia, cumulativeAdjointContErr):
sumLocalContErr = runTime.deltaTValue() * ref.fvc.div(phia).mag().weightedAverage(mesh.V()).value()
globalContErr = runTime.deltaTValue() * ref.fvc.div(phia).weightedAverage(mesh.V()).value()
cumulativeAdjointContErr += globalContErr
ref.ext_Info() << "Adjoint continuity errors : sum local = " << sumLocalContErr << ", global = " << globalContErr << ", cumulative = " << cumulativeAdjointContErr << ref.nl
return cumulativeAdjointContErr
def writeGradP( runTime, gradP ):
if runTime.outputTime():
gradPFile = ref.OFstream( runTime.path()/ref.fileName( runTime.timeName() )/ref.fileName( "uniform" )/ref.fileName( "gradP.raw" ) )
if gradPFile.good():
gradPFile << gradP << ref.nl
pass
else:
ref.ext_Info() << "Cannot open file " << runTime.path()/ref.fileName( runTime.timeName() )/ref.fileName( "uniform" )/ref.fileName( "gradP.raw" )
import os
os.abort()
def fun_pEqn( mesh, runTime, pimple, thermo, rho, p, h, psi, U, phi, turbulence, UEqn, rAU, DpDt, cumulativeContErr, corr, rhoMax, rhoMin ):
rho << thermo.rho()
rho << rho().ext_max( rhoMin )
rho << rho().ext_min( rhoMax )
rho.relax()
U << rAU() * UEqn.H()
if pimple.transonic():
phid = ref.surfaceScalarField( ref.word( "phid" ), ref.fvc.interpolate( psi ) * ( ( ref.fvc.interpolate( U ) & mesh.Sf() ) \
+ ref.fvc.ddtPhiCorr( rAU, rho, U, phi ) ) );
for nonOrth in range( pimple.nNonOrthCorr() + 1 ):
pEqn = ref.fvm.ddt( psi, p) + ref.fvm.div( phid, p ) - ref.fvm.laplacian( rho() * rAU, p ) # mixed calculations
pEqn.solve( mesh.solver( p.select( pimple.finalInnerIter( corr, nonOrth ) ) ) )
if nonOrth == pimple.nNonOrthCorr():
phi == pEqn.flux()
pass
pass
pass
else:
phi << ref.fvc.interpolate( rho ) * ( ( ref.fvc.interpolate( U ) & mesh.Sf() ) + ref.fvc.ddtPhiCorr( rAU, rho, U, phi ) )
for nonOrth in range( pimple.nNonOrthCorr() + 1 ):
pEqn = ref.fvm.ddt( psi, p ) + ref.fvc.div( phi ) - ref.fvm.laplacian( rho()*rAU, p ) # mixed calculations
pEqn.solve( mesh.solver( p.select( pimple.finalInnerIter( corr, nonOrth ) ) ) )
if nonOrth == pimple.nNonOrthCorr():
phi += pEqn.flux()
pass
pass
pass
ref.rhoEqn( rho, phi )
cumulativeContErr = ref.compressibleContinuityErrs( rho(), thermo, cumulativeContErr ) # mixed calculations
# Explicitly relax pressure for momentum corrector
p.relax()
# Recalculate density from the relaxed pressure
rho << thermo.rho()
rho << rho().ext_max( rhoMin )
rho << rho().ext_min( rhoMax )
rho.relax()
ref.ext_Info()<< "rho max/min : " << rho.ext_max().value() << " " << rho.ext_min().value() << ref.nl
U -= rAU * ref.fvc.grad( p )
U.correctBoundaryConditions()
DpDt << ref.fvc.DDt( ref.surfaceScalarField( ref.word( "phiU" ), phi() / ref.fvc.interpolate( rho ) ), p ) # mixed calculations
return cumulativeContErr
def createPhi( runTime, hU, mesh ):
ref.ext_Info() << "Reading/calculating face flux field phi\n" << ref.nl
phi = man.surfaceScalarField( man.IOobject( ref.word( "phi" ),
ref.fileName( runTime.timeName() ),
mesh,
ref.IOobject.READ_IF_PRESENT,
ref.IOobject.AUTO_WRITE ),
man.linearInterpolate( hU ) & man.surfaceVectorField( mesh.Sf(), man.Deps( mesh ) ) )
return phi
def createFields( runTime, mesh, g ):
ref.ext_Info() << "Reading thermophysical properties\n" << ref.nl
pThermo = man.basicPsiThermo.New( mesh );
rho = man.volScalarField( man.IOobject( ref.word( "rho" ),
ref.fileName( runTime.timeName() ),
mesh,
ref.IOobject.NO_READ,
ref.IOobject.NO_WRITE ),
man( pThermo.rho(), man.Deps( pThermo ) ) );
p = man( pThermo.p(), man.Deps( pThermo ) )
h = man( pThermo.h(), man.Deps( pThermo ) )
psi = man( pThermo.psi(), man.Deps( pThermo ) )
ref.ext_Info() << "Reading field U\n" << ref.nl
U = man.volVectorField( man.IOobject( ref.word( "U" ),
ref.fileName( runTime.timeName() ),
mesh,
ref.IOobject.MUST_READ,
ref.IOobject.AUTO_WRITE ),
mesh )
phi = man.compressibleCreatePhi( runTime, mesh, rho, U );
ref.ext_Info() << "Creating turbulence model\n" << ref.nl
turbulence = man.compressible.RASModel.New( rho, U, phi, pThermo );
ref.ext_Info()<< "Calculating field g.h\n" << ref.nl
gh = man.volScalarField( ref.word( "gh" ), man( g & mesh.C(), man.Deps( mesh ) ) )
ghf = man.surfaceScalarField( ref.word( "ghf" ), man( g & mesh.Cf(), man.Deps( mesh ) ) )
ref.ext_Info() << "Reading field p_rgh\n" << ref.nl
p_rgh = man.volScalarField( man.IOobject( ref.word( "p_rgh" ),
ref.fileName( runTime.timeName() ),
mesh,
ref.IOobject.MUST_READ,
ref.IOobject.AUTO_WRITE ),
mesh );
# Force p_rgh to be consistent with p
p_rgh << p - rho * gh
pRefCell = 0
pRefValue = 0.0
pRefCell, pRefValue = ref.setRefCell( p, p_rgh, mesh.solutionDict().subDict( ref.word( "SIMPLE" ) ), pRefCell, pRefValue );
initialMass = ref.fvc.domainIntegrate( rho )
totalVolume = mesh.V().ext_sum()
return pThermo, rho, p, h, psi, U, phi, turbulence, gh, ghf, p_rgh, pRefCell, pRefValue, initialMass, totalVolume
def setDeltaT(runTime, adjustTimeStep, maxCo, CoNum, maxAlphaCo, alphaCoNum,
maxDeltaT):
if adjustTimeStep:
maxDeltaTFact = min(maxCo / (CoNum + ref.SMALL),
maxAlphaCo / (alphaCoNum + ref.SMALL))
deltaTFact = min(min(maxDeltaTFact, 1.0 + 0.1 * maxDeltaTFact), 1.2)
runTime.setDeltaT(min(deltaTFact * runTime.deltaT().value(),
maxDeltaT))
ref.ext_Info() << "deltaT = " << runTime.deltaT().value() << ref.nl
pass
return runTime
def fun_pEqn( runTime, mesh, pimple, UEqn, p, p_rgh, phi, U, rho, rho1, rho2, rho10, rho20, gh, ghf, dgdt, pMin, \
psi1, psi2, alpha1, alpha2, interface, corr ):
rAU = 1.0 / UEqn.A()
rAUf = ref.fvc.interpolate(rAU)
p_rghEqnComp = None
if pimple.transonic():
p_rghEqnComp = ref.fvm.ddt(p_rgh) + ref.fvm.div(
phi, p_rgh) - ref.fvm.Sp(ref.fvc.div(phi), p_rgh)
pass
else:
p_rghEqnComp = ref.fvm.ddt(p_rgh) + ref.fvc.div(
phi, p_rgh) - ref.fvc.Sp(ref.fvc.div(phi), p_rgh)
pass
U << rAU * UEqn.H()
phiU = ref.surfaceScalarField(ref.word("phiU"),
(ref.fvc.interpolate(U) & mesh.Sf()) +
ref.fvc.ddtPhiCorr(rAU, rho, U, phi))
phi << (phiU +
(ref.fvc.interpolate(interface.sigmaK()) * ref.fvc.snGrad(alpha1) -
ghf * ref.fvc.snGrad(rho)) * rAUf * mesh.magSf())
for nonOrth in range(pimple.nNonOrthCorr() + 1):
p_rghEqnIncomp = ref.fvc.div(phi) - ref.fvm.laplacian(rAUf, p_rgh)
ref.solve(
(alpha1.ext_max(0.0) * (psi1 / rho1) + alpha2.ext_max(0.0) *
(psi2 / rho2)) * p_rghEqnComp() + p_rghEqnIncomp, ##
mesh.solver(p_rgh.select(pimple.finalInnerIter(corr, nonOrth))))
if nonOrth == pimple.nNonOrthCorr():
dgdt << (alpha2.pos() * (psi2 / rho2) - alpha1.pos() *
(psi1 / rho1)) * (p_rghEqnComp & p_rgh)
phi += p_rghEqnIncomp.flux()
pass
U += rAU * ref.fvc.reconstruct((phi() - phiU) / rAUf) # mixed calculations
U.correctBoundaryConditions()
p << ((p_rgh() + gh * (alpha1() * rho10 + alpha2 * rho20)) /
(1.0 - gh * (alpha1() * psi1 + alpha2 * psi2))).ext_max(pMin) #
rho1 << rho10 + psi1 * p
rho2 << rho20 + psi2 * p
ref.ext_Info() << "max(U) " << U.mag().ext_max().value() << ref.nl
ref.ext_Info() << "min(p_rgh) " << p_rgh.ext_min().value() << ref.nl
pass
def readTransportProperties(runTime, mesh):
ref.ext_Info() << "Reading transportProperties\n" << ref.nl
transportProperties = man.IOdictionary(
man.IOobject(ref.word("transportProperties"),
ref.fileName(runTime.constant()), mesh,
ref.IOobject.MUST_READ_IF_MODIFIED,
ref.IOobject.NO_WRITE))
mu = ref.dimensionedScalar(transportProperties.lookup(ref.word("mu")))
return transportProperties, mu
def createSolidField( solidRegions, runTime ):
thermos = list()
for index in range( solidRegions.__len__() ):
ref.ext_Info() << "*** Reading solid mesh thermophysical properties for region " \
<< solidRegions[ index ].name() << ref.nl << ref.nl
ref.ext_Info() << " Adding to thermos\n" << ref.nl
thermos.append( man.basicSolidThermo.New( solidRegions[ index ] ) )
pass
return thermos
def main_standalone( argc, argv ):
args = ref.setRootCase( argc, argv )
runTime = man.createTime( args )
mesh = man.createMesh( runTime )
U, phi, laminarTransport, turbulence, Ubar, gradP, flowDirection, flowMask = _createFields( runTime, mesh )
faceId, patchId, nWallFaces, wallNormal, cellId, y = interrogateWallPatches( mesh )
ref.ext_Info() << "\nStarting time loop\n" << ref.nl
while runTime.loop() :
ref.ext_Info() << "Time = " << runTime.timeName() << ref.nl << ref.nl
divR = turbulence.divDevReff( U )
divR.source()<< ( flowMask & divR.source() )
UEqn = divR == gradP
UEqn.relax()
UEqn.solve()
# Correct driving force for a constant mass flow rate
UbarStar = flowMask & U.weightedAverage(mesh.V())
U += Ubar - UbarStar
gradP += ( Ubar - UbarStar ) / ( 1.0 / UEqn.A() ).weightedAverage( mesh.V() )
turbulence.correct()
ref.ext_Info() << "Uncorrected Ubar = " << ( flowDirection & UbarStar.value() ) << \
", pressure gradient = " << ( flowDirection & gradP.value() )<< ref.nl
evaluateNearWall( turbulence, U, y, faceId, patchId, nWallFaces, wallNormal, cellId, flowDirection )
if runTime.outputTime():
makeGraphs( runTime, mesh, U, turbulence, faceId, patchId, nWallFaces, wallNormal, cellId, flowDirection, y )
pass
ref.ext_Info() << "ExecutionTime = " << runTime.elapsedCpuTime() << " s" << \
" ClockTime = " << runTime.elapsedClockTime() << " s" << ref.nl << ref.nl
pass
ref.ext_Info() << "End\n" << ref.nl
import os
return os.EX_OK
def compressibleCourantNo( mesh, amaxSf, runTime ):
CoNum = 0.0
meanCoNum = 0.0
if mesh.nInternalFaces():
amaxSfbyDelta = mesh.deltaCoeffs() * amaxSf
CoNum = ( amaxSfbyDelta / mesh.magSf() ).ext_max().value() * runTime.deltaT().value()
meanCoNum = ( amaxSfbyDelta.sum() / mesh.magSf().sum() ).value() * runTime.deltaTValue()
pass
ref.ext_Info() << "Mean and max Courant Numbers = " << meanCoNum << " " << CoNum << ref.nl
return CoNum, meanCoNum
def readTransportProperties( runTime, mesh ):
ref.ext_Info() << "Reading transportProperties\n" << ref.nl
transportProperties = man.IOdictionary( man.IOobject( ref.word( "transportProperties" ),
ref.fileName( runTime.constant() ),
mesh,
ref.IOobject.MUST_READ_IF_MODIFIED,
ref.IOobject.NO_WRITE ) )
nu = ref.dimensionedScalar( transportProperties.lookup( ref.word( "nu" ) ) )
return transportProperties, nu
def adjointContinuityErrs(runTime, mesh, phia, cumulativeAdjointContErr):
sumLocalContErr = runTime.deltaTValue() * ref.fvc.div(
phia).mag().weightedAverage(mesh.V()).value()
globalContErr = runTime.deltaTValue() * ref.fvc.div(phia).weightedAverage(
mesh.V()).value()
cumulativeAdjointContErr += globalContErr
ref.ext_Info() << "Adjoint continuity errors : sum local = " << sumLocalContErr << ", global = " << globalContErr \
<< ", cumulative = " << cumulativeAdjointContErr << ref.nl
return cumulativeAdjointContErr
def solidRegionDiffNo( mesh, runTime, Cprho, kappa ):
DiNum = 0.0
meanDiNum = 0.0
#- Take care: can have fluid domains with 0 cells so do not test for
# zero internal faces.
kapparhoCpbyDelta = mesh.deltaCoeffs() * ref.fvc.interpolate( kappa ) / ref.fvc.interpolate(Cprho)
DiNum = kapparhoCpbyDelta.internalField().gMax() * runTime.deltaT().value()
meanDiNum = kapparhoCpbyDelta.average().value() * runTime.deltaT().value()
ref.ext_Info() << "Region: " << mesh.name() << " Diffusion Number mean: " << meanDiNum << " max: " << DiNum << ref.nl
return DiNum
def alphaEqn( mesh, phi, alpha1, alphatab, Dab, rhoPhi, rho, rho1, rho2, turbulence ):
alpha1Eqn = ref.fvm.ddt( alpha1 ) + ref.fvm.div( phi, alpha1 ) - ref.fvm.laplacian( Dab + alphatab * turbulence.ext_nut(), alpha1, ref.word( "laplacian(Dab,alpha1)" ) )
alpha1Eqn.solve()
rhoPhi << alpha1Eqn.flux() * ( rho1 - rho2 ) + phi * rho2
rho << alpha1 * rho1 + ( ref.scalar( 1 ) - alpha1 ) * rho2
ref.ext_Info() << "Phase 1 volume fraction = " << alpha1.weightedAverage( mesh.V() ).value() \
<< " Min(alpha1) = " << alpha1.ext_min().value() << " Max(alpha1) = " << alpha1.ext_max().value() << ref.nl
pass
def setInitialMultiRegionDeltaT( adjustTimeStep, runTime, CoNum, DiNum, maxCo, maxDi, maxDeltaT ):
if adjustTimeStep:
if runTime.timeIndex() == 0 and ( CoNum > ref.SMALL or DiNum > ref.SMALL ) :
if CoNum < ref.SMALL:
CoNum = ref.SMALL
pass
if DiNum < ref.SMALL:
DiNum = ref.SMALL
pass
runTime.setDeltaT( min( min( maxCo / CoNum, maxDi / DiNum ) * runTime.deltaT().value(), maxDeltaT ) )
ref.ext_Info() << "deltaT = " << runTime.deltaT().value() << ref.nl
pass
return runTime, CoNum, DiNum
def _createFields( runTime, mesh ):
ref.ext_Info() << "Reading field T\n" << ref.nl
T = man.volScalarField( man.IOobject( ref.word( "T" ),
ref.fileName( runTime.timeName() ),
mesh,
ref.IOobject.MUST_READ,
ref.IOobject.AUTO_WRITE ),
mesh )
ref.ext_Info() << "Reading field U\n" << ref.nl
U = man.volVectorField( man.IOobject( ref.word( "U" ),
ref.fileName( runTime.timeName() ),
mesh,
ref.IOobject.MUST_READ,
ref.IOobject.AUTO_WRITE ),
mesh )
ref.ext_Info() << "Reading transportProperties\n" << ref.nl
transportProperties = man.IOdictionary( man.IOobject( ref.word( "transportProperties" ),
ref.fileName( runTime.constant() ),
mesh,
ref.IOobject.MUST_READ_IF_MODIFIED,
ref.IOobject.NO_WRITE ) )
ref.ext_Info() << "Reading diffusivity D\n" << ref.nl
DT = ref.dimensionedScalar( transportProperties.lookup( ref.word( "DT" ) ) )
phi = man.createPhi( runTime, mesh, U )
return T, U, transportProperties, DT, phi
def createFluidMeshes( rp, runTime ) :
fluidRegions = list()
for index in range( rp.fluidRegionNames().size() ) :
ref.ext_Info()<< "Create fluid mesh for region " << rp.fluidRegionNames()[ index ] \
<< " for time = " << runTime.timeName() << ref.nl << ref.nl
mesh = man.fvMesh( man.IOobject( rp.fluidRegionNames()[ index ],
ref.fileName( runTime.timeName() ),
runTime,
ref.IOobject.MUST_READ ) )
fluidRegions.append( mesh )
pass
return fluidRegions
def fun_hEqn( rho, h, phi, turb, DpDt, thermo, rad, mesh, oCorr, nOuterCorr, finalIter ) :
hEqn = ( ( ref.fvm.ddt( rho, h ) + ref.fvm.div( phi, h ) - ref.fvm.laplacian( turb.alphaEff(), h ) ) == DpDt() + rad.Sh( thermo() ) )
hEqn.relax()
hEqn.solve( mesh.solver( h.select( finalIter ) ) )
thermo.correct()
rad.correct()
ref.ext_Info()<< "Min/max T:" << thermo.T().ext_min().value() << ' ' \
<< thermo.T().ext_max().value() << ref.nl
pass
def readThermophysicalProperties(runTime, mesh):
ref.ext_Info() << "Reading thermophysicalProperties\n" << ref.nl
# Pr defined as a separate constant to enable calculation of k, currently
# inaccessible through thermo
thermophysicalProperties = man.IOdictionary(
man.IOobject(ref.word("thermophysicalProperties"),
ref.fileName(runTime.constant()), mesh,
ref.IOobject.MUST_READ, ref.IOobject.NO_WRITE))
Pr = ref.dimensionedScalar.lookupOrDefault(ref.word("Pr"),
thermophysicalProperties(), 1.0)
return thermophysicalProperties, Pr
def _createFields(runTime, mesh):
ref.ext_Info() << "Reading field T\n" << ref.nl
T = man.volScalarField(
man.IOobject(ref.word("T"), ref.fileName(runTime.timeName()), mesh,
ref.IOobject.MUST_READ, ref.IOobject.AUTO_WRITE), mesh)
ref.ext_Info() << "Reading field U\n" << ref.nl
U = man.volVectorField(
man.IOobject(ref.word("U"), ref.fileName(runTime.timeName()), mesh,
ref.IOobject.MUST_READ, ref.IOobject.AUTO_WRITE), mesh)
ref.ext_Info() << "Reading transportProperties\n" << ref.nl
transportProperties = man.IOdictionary(
man.IOobject(ref.word("transportProperties"),
ref.fileName(runTime.constant()), mesh,
ref.IOobject.MUST_READ_IF_MODIFIED,
ref.IOobject.NO_WRITE))
ref.ext_Info() << "Reading diffusivity D\n" << ref.nl
DT = ref.dimensionedScalar(transportProperties.lookup(ref.word("DT")))
phi = man.createPhi(runTime, mesh, U)
return T, U, transportProperties, DT, phi
def main_standalone( argc, argv ):
args = ref.setRootCase( argc, argv )
runTime = man.createTime( args )
mesh = man.createMesh( runTime )
T, transportProperties, DT = _createFields( runTime, mesh )
simple = man.simpleControl( mesh )
ref.ext_Info() << "\nCalculating temperature distribution\n" << ref.nl
while runTime.loop() :
ref.ext_Info() << "Time = " << runTime.timeName() << ref.nl << ref.nl
for nonOrth in range( simple.nNonOrthCorr() + 1 ):
ref.solve( ref.fvm.ddt( T ) - ref.fvm.laplacian( DT, T ) )
pass
write( runTime, mesh, T )
ref.ext_Info() << "ExecutionTime = " << runTime.elapsedCpuTime() << " s" << \
" ClockTime = " << runTime.elapsedClockTime() << " s" << ref.nl << ref.nl
pass
ref.ext_Info() << "End\n" << ref.nl
import os
return os.EX_OK
def createFluidMeshes(rp, runTime):
fluidRegions = list()
for index in range(rp.fluidRegionNames().size()):
ref.ext_Info()<< "Create fluid mesh for region " << rp.fluidRegionNames()[ index ] \
<< " for time = " << runTime.timeName() << ref.nl << ref.nl
mesh = man.fvMesh(
man.IOobject(rp.fluidRegionNames()[index],
ref.fileName(runTime.timeName()), runTime,
ref.IOobject.MUST_READ))
fluidRegions.append(mesh)
pass
return fluidRegions
def main_standalone(argc, argv):
args = ref.setRootCase(argc, argv)
runTime = man.createTime(args)
mesh = man.createMesh(runTime)
T, transportProperties, DT = _createFields(runTime, mesh)
simple = man.simpleControl(mesh)
ref.ext_Info() << "\nCalculating temperature distribution\n" << ref.nl
while runTime.loop():
ref.ext_Info() << "Time = " << runTime.timeName() << ref.nl << ref.nl
while simple.correctNonOrthogonal():
ref.solve(ref.fvm.ddt(T) - ref.fvm.laplacian(DT, T))
pass
write(runTime, mesh, T)
ref.ext_Info() << "ExecutionTime = " << runTime.elapsedCpuTime() << " s" << \
" ClockTime = " << runTime.elapsedClockTime() << " s" << ref.nl << ref.nl
pass
ref.ext_Info() << "End\n" << ref.nl
import os
return os.EX_OK
def createFields(runTime, mesh, g):
ref.ext_Info() << "Reading thermophysical properties\n" << ref.nl
pThermo = man.basicPsiThermo.New(mesh)
rho = man.volScalarField(
man.IOobject(ref.word("rho"), ref.fileName(runTime.timeName()), mesh,
ref.IOobject.NO_READ, ref.IOobject.NO_WRITE),
man(pThermo.rho(), man.Deps(pThermo)))
p = man(pThermo.p(), man.Deps(pThermo))
h = man(pThermo.h(), man.Deps(pThermo))
psi = man(pThermo.psi(), man.Deps(pThermo))
ref.ext_Info() << "Reading field U\n" << ref.nl
U = man.volVectorField(
man.IOobject(ref.word("U"), ref.fileName(runTime.timeName()), mesh,
ref.IOobject.MUST_READ, ref.IOobject.AUTO_WRITE), mesh)
phi = man.compressibleCreatePhi(runTime, mesh, rho, U)
ref.ext_Info() << "Creating turbulence model\n" << ref.nl
turbulence = man.compressible.RASModel.New(rho, U, phi, pThermo)
ref.ext_Info() << "Calculating field g.h\n" << ref.nl
gh = man.volScalarField(ref.word("gh"), man(g & mesh.C(), man.Deps(mesh)))
ghf = man.surfaceScalarField(ref.word("ghf"),
man(g & mesh.Cf(), man.Deps(mesh)))
ref.ext_Info() << "Reading field p_rgh\n" << ref.nl
p_rgh = man.volScalarField(
man.IOobject(ref.word("p_rgh"), ref.fileName(runTime.timeName()), mesh,
ref.IOobject.MUST_READ, ref.IOobject.AUTO_WRITE), mesh)
# Force p_rgh to be consistent with p
p_rgh << p - rho * gh
pRefCell = 0
pRefValue = 0.0
pRefCell, pRefValue = ref.setRefCell(
p, p_rgh,
mesh.solutionDict().subDict(ref.word("SIMPLE")), pRefCell, pRefValue)
initialMass = ref.fvc.domainIntegrate(rho)
totalVolume = mesh.V().ext_sum()
return pThermo, rho, p, h, psi, U, phi, turbulence, gh, ghf, p_rgh, pRefCell, pRefValue, initialMass, totalVolume
def compressibleCourantNo( mesh, runTime, rho, phi ) :
CoNum = 0.0
meanCoNum = 0.0
tmp = ref.fvc.surfaceSum( phi.mag() )
sumPhi = tmp.internalField() / rho.internalField()
CoNum = 0.5 * ( sumPhi / mesh.V().field() ).gMax() * runTime.deltaTValue()
meanCoNum = 0.5 * ( sumPhi.gSum() / mesh.V().field().gSum() ) * runTime.deltaTValue()
ref.ext_Info() << "Region: " << mesh.name() << " Courant Number mean: " << meanCoNum \
<< " max: " << CoNum << ref.nl
return CoNum
def _createFields(runTime, mesh):
ref.ext_Info() << "Reading field p\n" << ref.nl
p = man.volScalarField(
man.IOobject(ref.word("p"), ref.fileName(runTime.timeName()), mesh,
ref.IOobject.MUST_READ, ref.IOobject.AUTO_WRITE), mesh)
ref.ext_Info() << "Reading field U\n" << ref.nl
U = man.volVectorField(
man.IOobject(ref.word("U"), ref.fileName(runTime.timeName()), mesh,
ref.IOobject.MUST_READ, ref.IOobject.AUTO_WRITE), mesh)
phi = man.createPhi(runTime, mesh, U)
return p, U, phi
def fun_hEqn( rho, h, phi, turb, K, dpdt, thermo, rad, mesh, oCorr, nOuterCorr, finalIter ):
hEqn = ( ( ref.fvm.ddt( rho, h ) + ref.fvm.div( phi, h ) - ref.fvm.laplacian( turb.alphaEff(), h ) ) \
== dpdt() - ( ref.fvc.ddt( rho, K ) + ref.fvc.div( phi, K ) ) + rad.Sh( thermo() ) ) # mixed calculation
hEqn.relax()
hEqn.solve( mesh.solver( h.select( finalIter ) ) )
thermo.correct()
rad.correct()
ref.ext_Info()<< "Min/max T:" << thermo.T().ext_min().value() << ' ' \
<< thermo.T().ext_max().value() << ref.nl
pass
def readTurbulenceProperties(runTime, mesh, U):
ref.ext_Info() << "Reading turbulenceProperties\n" << ref.nl
turbulenceProperties = man.IOdictionary(
man.IOobject(ref.word("turbulenceProperties"),
ref.fileName(runTime.constant()), mesh,
ref.IOobject.MUST_READ_IF_MODIFIED,
ref.IOobject.NO_WRITE))
force = U / ref.dimensionedScalar(ref.word("dt"), ref.dimTime,
runTime.deltaTValue())
K = man.Kmesh(mesh)
forceGen = man.UOprocess(K, runTime.deltaTValue(), turbulenceProperties)
return turbulenceProperties, force, K, forceGen
def compressibleContinuityErrors( i, mesh, rho, thermo, cumulativeContErr ) :
totalMass = ref.fvc.domainIntegrate(rho)
sumLocalContErr = ( ref.fvc.domainIntegrate( ( rho() - thermo.rho() ).mag() ) / totalMass ).value() # mixed calculations
globalContErr = ( ref.fvc.domainIntegrate( rho() - thermo.rho() ) / totalMass ).value() # mixed calculations
cumulativeContErr[i] = cumulativeContErr[i] + globalContErr
ref.ext_Info()<< "time step continuity errors (" << mesh.name() << ")" \
<< ": sum local = " << sumLocalContErr \
<< ", global = " << globalContErr \
<< ", cumulative = " << cumulativeContErr[i] \
<< ref.nl
return cumulativeContErr
def main_standalone(argc, argv):
args = ref.setRootCase(argc, argv)
runTime = man.createTime(args)
mesh = man.createMesh(runTime)
p, U, phi, turbulence, pRefCell, pRefValue, laminarTransport, sources = _createFields(
runTime, mesh)
cumulativeContErr = ref.initContinuityErrs()
pimple = man.pimpleControl(mesh)
ref.ext_Info() << "\nStarting time loop\n" << ref.nl
while runTime.run():
adjustTimeStep, maxCo, maxDeltaT = ref.readTimeControls(runTime)
CoNum, meanCoNum = ref.CourantNo(mesh, phi, runTime)
runTime = ref.setDeltaT(runTime, adjustTimeStep, maxCo, maxDeltaT,
CoNum)
runTime.increment()
ref.ext_Info() << "Time = " << runTime.timeName() << ref.nl << ref.nl
# --- Pressure-velocity PIMPLE corrector loop
while pimple.loop():
UEqn, rAU = Ueqn(mesh, pimple, phi, U, p, turbulence, sources)
# --- Pressure corrector loop
while pimple.correct():
cumulativeContErr = pEqn(runTime, mesh, pimple, U, rAU, UEqn,
phi, p, pRefCell, pRefValue,
cumulativeContErr, sources)
pass
if pimple.turbCorr():
turbulence.correct()
pass
pass
runTime.write()
ref.ext_Info() << "ExecutionTime = " << runTime.elapsedCpuTime() << " s" << \
" ClockTime = " << runTime.elapsedClockTime() << " s" << ref.nl << ref.nl
pass
ref.ext_Info() << "End\n" << ref.nl
import os
return os.EX_OK
