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):
ref.ext_Info() << "Reading thermophysical properties\n" << ref.nl
pThermo = man.basicPsiThermo.New(mesh)
p = man.volScalarField(pThermo.p(), man.Deps(pThermo))
e = man.volScalarField(pThermo.e(), man.Deps(pThermo))
psi = man.volScalarField(pThermo.psi(), man.Deps(pThermo))
rho = man.volScalarField(
man.IOobject(ref.word("rho"), ref.fileName(runTime.timeName()), mesh),
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, rho, U)
ref.ext_Info() << "Creating turbulence model\n" << ref.nl
turbulence = man.compressible.turbulenceModel.New(rho, U, phi, pThermo)
return pThermo, p, e, psi, rho, U, phi, turbulence
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 _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)
ref.ext_Info() << "Reading field rAU if present\n" << ref.nl
rAU = man.volScalarField(
man.IOobject(ref.word("rAU"), ref.fileName(runTime.timeName()), mesh,
ref.IOobject.READ_IF_PRESENT, ref.IOobject.AUTO_WRITE),
mesh, runTime.deltaT(), ref.zeroGradientFvPatchScalarField.typeName)
sources = man.IObasicSourceList(mesh)
return p, U, phi, laminarTransport, turbulence, rAU, pRefCell, pRefValue, sources
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 _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 _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):
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 _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 Urel\n" << ref.nl
Urel = man.volVectorField( man.IOobject( ref.word( "Urel" ),
ref.fileName( runTime.timeName() ),
mesh,
ref.IOobject.MUST_READ,
ref.IOobject.AUTO_WRITE ),
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.surfaceScalarField( ref.linearInterpolate( Urel ) & mesh.Sf(), man.Deps( mesh, Urel ) ) )
pRefCell = 0
pRefValue = 0.0
pRefCell, pRefValue = ref.setRefCell( p, mesh.solutionDict().subDict( ref.word( "PIMPLE" ) ), pRefCell, pRefValue )
laminarTransport = man.singlePhaseTransportModel( Urel, phi )
turbulence = man.incompressible.turbulenceModel.New( Urel, phi, laminarTransport )
ref.ext_Info() << "Creating SRF model\n" << ref.nl
SRF = man.SRF.SRFModel.New( Urel )
sources = man.IObasicSourceList( mesh )
# Create the absolute velocity
U = man.volVectorField( man.IOobject( ref.word( "U" ),
ref.fileName( runTime.timeName() ),
mesh,
ref.IOobject.NO_READ,
ref.IOobject.AUTO_WRITE ),
man.volVectorField( Urel() + SRF.U(), man.Deps( Urel, SRF ) ) ) # mixed calculations
return p, U, Urel, SRF, phi, turbulence, pRefCell, pRefValue, laminarTransport, sources
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 _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 createFields(runTime, mesh, g):
ref.ext_Info() << "Reading thermophysical properties\n" << ref.nl
pThermo = man.basicRhoThermo.New(mesh)
rho = man.volScalarField(
man.IOobject(ref.word("rho"), ref.fileName(runTime.timeName()), mesh,
ref.IOobject.NO_READ, ref.IOobject.NO_WRITE),
man.volScalarField(pThermo.rho(), man.Deps(pThermo)))
p = man.volScalarField(pThermo.p(), man.Deps(pThermo))
h = man.volScalarField(pThermo.h(), man.Deps(pThermo))
psi = man.volScalarField(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, U, rho)
ref.ext_Info() << "Creating turbulence model\n" << ref.nl
turbulence = man.compressible.turbulenceModel.New(rho, U, phi, pThermo)
ref.ext_Info() << "Calculating field g.h\n" << ref.nl
gh = man.volScalarField(ref.word("gh"),
man.volScalarField(g & mesh.C(), man.Deps(mesh)))
ghf = man.surfaceScalarField(
ref.word("ghf"), man.surfaceScalarField(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
ref.ext_Info() << "Creating field DpDt\n" << ref.nl
DpDt = man.volScalarField(
ref.word("DpDt"),
man.fvc.DDt(
man.surfaceScalarField(ref.word("phiU"),
phi / man.fvc.interpolate(rho)), p))
return pThermo, p, rho, h, psi, U, phi, turbulence, gh, ghf, p_rgh, DpDt
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 setInitialrDeltaT(runTime, mesh, pimple):
maxDeltaT = pimple.dict().lookupOrDefault(ref.word("maxDeltaT"), ref.GREAT)
rDeltaT = man.volScalarField(
man.IOobject(ref.word("rDeltaT"), ref.fileName(runTime.timeName()),
mesh, ref.IOobject.NO_READ,
ref.IOobject.AUTO_WRITE), mesh, 1.0 /
ref.dimensionedScalar(ref.word("maxDeltaT"), ref.dimTime, maxDeltaT),
ref.zeroGradientFvPatchScalarField.typeName)
return maxDeltaT, rDeltaT
def _createFields(runTime, mesh, Omega, gHat):
ref.ext_Info() << "Reading field h\n" << ref.nl
h = man.volScalarField(
man.IOobject(ref.word("h"), ref.fileName(runTime.timeName()), mesh,
ref.IOobject.MUST_READ, ref.IOobject.AUTO_WRITE), mesh)
ref.ext_Info() << "Reading field h0 if present\n" << ref.nl
h0 = man.volScalarField(
man.IOobject(
ref.word("h0"),
ref.fileName(
runTime.findInstance(ref.fileName(ref.word("polyMesh")),
ref.word("points"))), mesh,
ref.IOobject.READ_IF_PRESENT), mesh,
ref.dimensionedScalar(ref.word("h0"), ref.dimLength, 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)
ref.ext_Info() << "Creating field hU\n" << ref.nl
hU = man.volVectorField(
man.IOobject(ref.word("hU"), ref.fileName(runTime.timeName()), mesh),
h * U,
U.ext_boundaryField().types())
ref.ext_Info() << "Creating field hTotal for post processing\n" << ref.nl
hTotal = man.volScalarField(
man.IOobject(ref.word("hTotal"), ref.fileName(runTime.timeName()),
mesh, ref.IOobject.READ_IF_PRESENT,
ref.IOobject.AUTO_WRITE), h + h0)
hTotal.write()
phi = createPhi(runTime, hU, mesh)
ref.ext_Info() << "Creating Coriolis Force" << ref.nl
F = ref.dimensionedVector(ref.word("F"), ((2.0 * Omega) & gHat) * gHat)
return h, h0, U, hU, hTotal, phi, F
def _createFields( runTime, mesh, simple ):
ref.ext_Info() << "Reading thermophysical properties\n" << ref.nl
thermo = man.basicPsiThermo.New( mesh )
rho = man.volScalarField( man.IOobject( ref.word( "rho" ),
ref.fileName( runTime.timeName() ),
mesh,
ref.IOobject.READ_IF_PRESENT,
ref.IOobject.AUTO_WRITE ),
man.volScalarField( thermo.rho(), man.Deps( thermo ) ) )
p = man.volScalarField( thermo.p(), man.Deps( thermo ) )
h = man.volScalarField( thermo.h(), man.Deps( thermo ) )
psi = man.volScalarField( thermo.psi(), man.Deps( thermo ) )
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 )
pRefCell = 0
pRefValue = 0.0
pRefCell, pRefValue = ref.setRefCell( p, simple.dict(), pRefCell, pRefValue )
rhoMax = ref.dimensionedScalar( simple.dict().lookup( ref.word( "rhoMax" ) ) )
rhoMin = ref.dimensionedScalar( simple.dict().lookup( ref.word( "rhoMin" ) ) )
ref.ext_Info() << "Creating turbulence model\n" << ref.nl
turbulence = man.compressible.RASModel.New( rho,
U,
phi,
thermo )
initialMass = ref.fvc.domainIntegrate( rho )
return thermo, rho, p, h, psi, U, phi, pRefCell, pRefValue, turbulence, initialMass, rhoMax, rhoMin
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 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 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 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 createFields( runTime, mesh ):
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( mesh.solutionDict().subDict( ref.word( "PIMPLE" ) ).lookup( ref.word( "rhoMax" ) ) )
rhoMin = ref.dimensionedScalar( mesh.solutionDict().subDict( ref.word( "PIMPLE" ) ).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.fvc.DDt( man.surfaceScalarField( ref.word( "phiU" ), phi / man.fvc.interpolate( rho ) ), p )
return pThermo, p, h, psi, rho, U, phi, rhoMax, rhoMin, turbulence, DpDt
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 _createFields(runTime, mesh):
# Load boundary condition
from BCs import rho
ref.ext_Info() << "Reading thermophysical properties\n" << ref.nl
thermo = man.basicPsiThermo.New(mesh)
p = man.volScalarField(thermo.p(), man.Deps(thermo))
e = man.volScalarField(thermo.e(), man.Deps(thermo))
T = man.volScalarField(thermo.T(), man.Deps(thermo))
psi = man.volScalarField(thermo.psi(), man.Deps(thermo))
mu = man.volScalarField(thermo.mu(), man.Deps(thermo))
inviscid = True
if mu.internalField().max() > 0.0:
inviscid = False
pass
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)
pbf, rhoBoundaryTypes = _rhoBoundaryTypes(p)
rho = man.volScalarField(
man.IOobject(ref.word("rho"), ref.fileName(runTime.timeName()), mesh,
ref.IOobject.NO_READ, ref.IOobject.AUTO_WRITE),
man.volScalarField(thermo.rho(), man.Deps(thermo)), rhoBoundaryTypes)
rhoU = man.volVectorField(
man.IOobject(ref.word("rhoU"), ref.fileName(runTime.timeName()), mesh,
ref.IOobject.NO_READ, ref.IOobject.NO_WRITE), rho * U)
rhoE = man.volScalarField(
man.IOobject(ref.word("rhoE"), ref.fileName(runTime.timeName()), mesh,
ref.IOobject.NO_READ, ref.IOobject.NO_WRITE),
rho * (e + man.volScalarField(0.5 * U.magSqr(), man.Deps(U))))
pos = man.surfaceScalarField(
man.IOobject(ref.word("pos"), ref.fileName(runTime.timeName()), mesh),
mesh, ref.dimensionedScalar(ref.word("pos"), ref.dimless, 1.0))
neg = man.surfaceScalarField(
man.IOobject(ref.word("neg"), ref.fileName(runTime.timeName()), mesh),
mesh, ref.dimensionedScalar(ref.word("neg"), ref.dimless, -1.0))
phi = man.surfaceScalarField(
ref.word("phi"),
man.surfaceVectorField(mesh.Sf(), man.Deps(mesh))
& man.fvc.interpolate(rhoU))
ref.ext_Info() << "Creating turbulence model\n" << ref.nl
turbulence = man.compressible.turbulenceModel.New(rho, U, phi, thermo)
return thermo, p, e, T, psi, mu, U, pbf, rhoBoundaryTypes, rho, rhoU, rhoE, pos, neg, inviscid, phi, turbulence
def readThermodynamicProperties(runTime, mesh):
ref.ext_Info() << "Reading thermodynamicProperties\n" << ref.nl
thermodynamicProperties = man.IOdictionary(
man.IOobject(ref.word("thermodynamicProperties"),
ref.fileName(runTime.constant()), mesh,
ref.IOobject.MUST_READ_IF_MODIFIED,
ref.IOobject.NO_WRITE))
rho0 = ref.dimensionedScalar(
thermodynamicProperties.lookup(ref.word("rho0")))
p0 = ref.dimensionedScalar(thermodynamicProperties.lookup(ref.word("p0")))
psi = ref.dimensionedScalar(thermodynamicProperties.lookup(
ref.word("psi")))
# Density offset, i.e. the constant part of the density
rhoO = ref.dimensionedScalar(ref.word("rhoO"), rho0 - psi * p0)
return thermodynamicProperties, rho0, p0, psi, rhoO
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):
# Load boundary conditions
import adjointOutletPressure
import adjointOutletVelocity
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
ref.setRefCell(p,
mesh.solutionDict().subDict(ref.word("SIMPLE")), pRefCell,
pRefValue)
ref.ext_Info() << "Reading field pa\n" << ref.nl
pa = man.volScalarField(
man.IOobject(ref.word("pa"), ref.fileName(runTime.timeName()), mesh,
ref.IOobject.MUST_READ, ref.IOobject.AUTO_WRITE), mesh)
ref.ext_Info() << "Reading field Ua\n" << ref.nl
Ua = man.volVectorField(
man.IOobject(ref.word("Ua"), ref.fileName(runTime.timeName()), mesh,
ref.IOobject.MUST_READ, ref.IOobject.AUTO_WRITE), mesh)
phia = createPhia(runTime, mesh, Ua)
paRefCell = 0
paRefValue = 0.0
ref.setRefCell(pa,
mesh.solutionDict().subDict(ref.word("SIMPLE")), paRefCell,
paRefValue)
laminarTransport = man.singlePhaseTransportModel(U, phi)
turbulence = man.incompressible.RASModel.New(U, phi, laminarTransport)
zeroSensitivity = ref.dimensionedScalar(ref.word("0"),
ref.dimVelocity * ref.dimVelocity,
0.0)
zeroAlpha = ref.dimensionedScalar(ref.word("0"), ref.dimless / ref.dimTime,
0.0)
lambda_ = ref.dimensionedScalar(laminarTransport.lookup(
ref.word("lambda")))
alphaMax = ref.dimensionedScalar(
laminarTransport.lookup(ref.word("alphaMax")))
inletCells = mesh.boundary()[ref.word("inlet")].faceCells()
# outletCells = mesh.boundary()[ ref.word( "outlet" ) ].faceCells()
alpha = man.volScalarField(
man.IOobject(ref.word("alpha"), ref.fileName(runTime.timeName()), mesh,
ref.IOobject.READ_IF_PRESENT, ref.IOobject.AUTO_WRITE),
lambda_ * (Ua & U).ext_max(zeroSensitivity))
zeroCells(alpha, inletCells)
# zeroCells( alpha, outletCells )
return p, U, phi, pa, Ua, phia, alpha, laminarTransport, turbulence, zeroSensitivity, zeroAlpha, \
lambda_, alphaMax, inletCells, pRefCell, pRefValue, paRefCell, paRefValue
def _createFields(runTime, 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)
ref.ext_Info() << "Reading field alpha1\n" << ref.nl
man.interfaceProperties # Load corresponding library to be able to use the following BC - "constantAlphaContactAngleFvPatchScalarField"
alpha1 = man.volScalarField(
man.IOobject(ref.word("alpha1"), 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)
ref.ext_Info() << "Reading transportProperties\n" << ref.nl
twoPhaseProperties = man.twoPhaseMixture(U, phi)
rho1 = twoPhaseProperties.rho1()
rho2 = twoPhaseProperties.rho2()
# Need to store rho for ddt(rho, U)
rho = man.volScalarField(
man.IOobject(ref.word("rho"), ref.fileName(runTime.timeName()), mesh,
ref.IOobject.READ_IF_PRESENT),
alpha1 * rho1 + (1.0 - alpha1) * rho2,
alpha1.ext_boundaryField().types())
rho.oldTime()
# Mass flux
# Initialisation does not matter because rhoPhi is reset after the
# alpha1 solution before it is used in the U equation.
rhoPhi = man.surfaceScalarField(
man.IOobject(ref.word("rho*phi"), ref.fileName(runTime.timeName()),
mesh, ref.IOobject.NO_READ, ref.IOobject.NO_WRITE),
rho1 * phi)
# Construct interface from alpha1 distribution
interface = man.interfaceProperties(alpha1, U, twoPhaseProperties)
# Construct incompressible turbulence model
turbulence = man.incompressible.turbulenceModel.New(
U, phi, twoPhaseProperties)
g = man.readGravitationalAcceleration(runTime, mesh)
#dimensionedVector g0(g);
#Read the data file and initialise the interpolation table
#interpolationTable<vector> timeSeriesAcceleration( runTime.path()/runTime.caseConstant()/"acceleration.dat" );
ref.ext_Info() << "Calculating field g.h\n" << ref.nl
gh = man.volScalarField(ref.word("gh"),
g & man.volVectorField(mesh.C(), man.Deps(mesh)))
ghf = man.surfaceScalarField(
ref.word("ghf"), g & man.surfaceVectorField(mesh.Cf(), man.Deps(mesh)))
p = man.volScalarField(
man.IOobject(ref.word("p"), ref.fileName(runTime.timeName()), mesh,
ref.IOobject.NO_READ, ref.IOobject.AUTO_WRITE),
p_rgh + rho * gh)
pRefCell = 0
pRefValue = 0.0
pRefCell, pRefValue = ref.setRefCell(
p, p_rgh,
mesh.solutionDict().subDict(ref.word("PIMPLE")), pRefCell, pRefValue)
if p_rgh.needReference():
p += ref.dimensionedScalar(
ref.word("p"), p.dimensions(),
pRefValue - ref.getRefCellValue(p, pRefCell))
p_rgh << p - rho * gh
pass
return p_rgh, p, alpha1, U, phi, rho1, rho2, rho, rhoPhi, twoPhaseProperties, pRefCell, pRefValue, interface, turbulence, g, gh, ghf
def createFields( runTime, mesh, g ):
ref.ext_Info() << "Reading thermophysical properties\n" << ref.nl
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 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 )
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 )
laminarTransport, beta, TRef, Pr, Prt = readTransportProperties( U, phi )
ref.ext_Info()<< "Creating turbulence model\n" << ref.nl
turbulence = man.incompressible.RASModel.New(U, phi, laminarTransport)
# Kinematic density for buoyancy force
rhok = man.volScalarField( man.IOobject( ref.word( "rhok" ),
ref.fileName( runTime.timeName() ),
mesh ), man( 1.0 - beta * ( T() - TRef ), man.Deps( T ) ) )
# kinematic turbulent thermal thermal conductivity m2/s
ref.ext_Info() << "Reading field kappat\n" << ref.nl
kappat = man.volScalarField( man.IOobject( ref.word( "kappat" ),
ref.fileName( runTime.timeName() ),
mesh,
ref.IOobject.MUST_READ,
ref.IOobject.AUTO_WRITE ), mesh )
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 ) ) )
p = man.volScalarField( man.IOobject( ref.word( "p" ),
ref.fileName( runTime.timeName() ),
mesh,
ref.IOobject.NO_READ,
ref.IOobject.AUTO_WRITE ), p_rgh + rhok * gh )
pRefCell = 0
pRefValue = 0.0
pRefCell, pRefValue = ref.setRefCell( p, p_rgh, mesh.solutionDict().subDict( ref.word( "SIMPLE" ) ), pRefCell, pRefValue )
if p_rgh.needReference():
p += ref.dimensionedScalar( ref.word( "p" ),p.dimensions(), pRefValue - ref.getRefCellValue( p, pRefCell ) )
pass
return T, p_rgh, U, phi, laminarTransport, turbulence, rhok, kappat, gh, ghf, p, pRefCell, pRefValue, beta, TRef, Pr, Prt
def createFluidFields(fluidRegions, runTime):
# Initialise fluid field pointer lists
thermoFluid = list()
rhoFluid = list()
KFluid = list()
UFluid = list()
phiFluid = list()
gFluid = list()
turbulence = list()
p_rghFluid = list()
ghFluid = list()
ghfFluid = list()
radiation = list()
DpDtFluid = list()
initialMassFluid = list()
#Populate fluid field pointer lists
for index in range(fluidRegions.__len__()):
ref.ext_Info() << "*** Reading fluid mesh thermophysical properties for region " \
<< fluidRegions[ index ].name() << ref.nl << ref.nl
ref.ext_Info() << " Adding to thermoFluid\n" << ref.nl
thermo = man.basicRhoThermo.New(fluidRegions[index])
thermoFluid.append(thermo)
ref.ext_Info() << " Adding to rhoFluid\n" << ref.nl
rhoFluid.append(
man.volScalarField(
man.IOobject(ref.word("rho"), ref.fileName(runTime.timeName()),
fluidRegions[index], ref.IOobject.NO_READ,
ref.IOobject.AUTO_WRITE),
man.volScalarField(thermoFluid[index].rho(),
man.Deps(thermoFluid[index]))))
ref.ext_Info() << " Adding to KFluid\n" << ref.nl
KFluid.append(
man.volScalarField(
man.IOobject(ref.word("K"), ref.fileName(runTime.timeName()),
fluidRegions[index], ref.IOobject.NO_READ,
ref.IOobject.NO_WRITE),
man.volScalarField(
thermoFluid[index].Cp() * thermoFluid[index].alpha(),
man.Deps(thermoFluid[index]))))
ref.ext_Info() << " Adding to UFluid\n" << ref.nl
UFluid.append(
man.volVectorField(
man.IOobject(ref.word("U"), ref.fileName(runTime.timeName()),
fluidRegions[index], ref.IOobject.MUST_READ,
ref.IOobject.AUTO_WRITE), fluidRegions[index]))
ref.ext_Info() << " Adding to phiFluid\n" << ref.nl
phiFluid.append(
man.surfaceScalarField(
man.IOobject(ref.word("phi"), ref.fileName(runTime.timeName()),
fluidRegions[index], ref.IOobject.READ_IF_PRESENT,
ref.IOobject.AUTO_WRITE),
man.linearInterpolate(rhoFluid[index] * UFluid[index])
& man.surfaceVectorField(fluidRegions[index].Sf(),
man.Deps(fluidRegions[index]))))
ref.ext_Info() << " Adding to gFluid\n" << ref.nl
gFluid.append(
man.uniformDimensionedVectorField(
man.IOobject(ref.word("g"), ref.fileName(runTime.constant()),
fluidRegions[index], ref.IOobject.MUST_READ,
ref.IOobject.NO_WRITE)))
ref.ext_Info() << " Adding to turbulence\n" << ref.nl
turbulence.append(
man.compressible.turbulenceModel.New(rhoFluid[index],
UFluid[index],
phiFluid[index],
thermoFluid[index]))
ref.ext_Info() << " Adding to ghFluid\n" << ref.nl
ghFluid.append(
man.volScalarField(
ref.word("gh"), gFluid[index] & man.volVectorField(
fluidRegions[index].C(), man.Deps(fluidRegions[index]))))
ref.ext_Info() << " Adding to ghfFluid\n" << ref.nl
ghfFluid.append(
man.surfaceScalarField(
ref.word("ghf"), gFluid[index] & man.surfaceVectorField(
fluidRegions[index].Cf(), man.Deps(fluidRegions[index]))))
p_rghFluid.append(
man.volScalarField(
man.IOobject(ref.word("p_rgh"),
ref.fileName(runTime.timeName()),
fluidRegions[index], ref.IOobject.MUST_READ,
ref.IOobject.AUTO_WRITE), fluidRegions[index]))
# Force p_rgh to be consistent with p
p_rghFluid[index] << thermoFluid[index].p()(
) - rhoFluid[index] * ghFluid[index]
radiation.append(
man.radiation.radiationModel.New(
man.volScalarField(thermoFluid[index].T(),
man.Deps(thermoFluid[index]))))
initialMassFluid.append(
ref.fvc.domainIntegrate(rhoFluid[index]).value())
ref.ext_Info() << " Adding to DpDtFluid\n" << ref.nl
DpDtFluid.append(
man.volScalarField(
ref.word("DpDt"),
man.fvc.DDt(
man.surfaceScalarField(
ref.word("phiU"), phiFluid[index] /
man.fvc.interpolate(rhoFluid[index])),
man.volScalarField(thermoFluid[index].p(),
man.Deps(thermoFluid[index])))))
return thermoFluid, rhoFluid, KFluid, UFluid, phiFluid, gFluid, turbulence, DpDtFluid, initialMassFluid, ghFluid, ghfFluid, p_rghFluid, radiation
def _createFields(runTime, mesh, g):
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)
ref.ext_Info() << "Reading field alpha1\n" << ref.nl
alpha1 = man.volScalarField(
man.IOobject(ref.word("alpha1"), ref.fileName(runTime.timeName()),
mesh, ref.IOobject.MUST_READ, ref.IOobject.AUTO_WRITE),
mesh)
ref.ext_Info() << "Calculating field alpha1\n" << ref.nl
alpha2 = man.volScalarField(ref.word("alpha2"), 1.0 - alpha1)
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)
ref.ext_Info() << "Reading transportProperties\n" << ref.nl
twoPhaseProperties = man.twoPhaseMixture(U, phi)
rho10 = ref.dimensionedScalar(
twoPhaseProperties.subDict(twoPhaseProperties.phase1Name()).lookup(
ref.word("rho0")))
rho20 = ref.dimensionedScalar(
twoPhaseProperties.subDict(twoPhaseProperties.phase2Name()).lookup(
ref.word("rho0")))
psi1 = ref.dimensionedScalar(
twoPhaseProperties.subDict(twoPhaseProperties.phase1Name()).lookup(
ref.word("psi")))
psi2 = ref.dimensionedScalar(
twoPhaseProperties.subDict(twoPhaseProperties.phase2Name()).lookup(
ref.word("psi")))
pMin = ref.dimensionedScalar(twoPhaseProperties.lookup(ref.word("pMin")))
ref.ext_Info() << "Calculating field g.h\n" << ref.nl
gh = man.volScalarField(ref.word("gh"),
g & man.volVectorField(mesh.C(), man.Deps(mesh)))
ghf = man.surfaceScalarField(
ref.word("ghf"), g & man.surfaceVectorField(mesh.Cf(), man.Deps(mesh)))
p = man.volScalarField(
man.IOobject(ref.word("p"), ref.fileName(runTime.timeName()), mesh,
ref.IOobject.NO_READ, ref.IOobject.AUTO_WRITE),
((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
rho = man.volScalarField(
man.IOobject(ref.word("rho"), ref.fileName(runTime.timeName()), mesh,
ref.IOobject.READ_IF_PRESENT, ref.IOobject.AUTO_WRITE),
alpha1 * rho1 + alpha2 * rho2)
# Mass flux
# Initialisation does not matter because rhoPhi is reset after the
# alpha1 solution before it is used in the U equation.
rhoPhi = man.surfaceScalarField(
man.IOobject(ref.word("rho*phi"), ref.fileName(runTime.timeName()),
mesh, ref.IOobject.NO_READ, ref.IOobject.NO_WRITE),
man.fvc.interpolate(rho) * phi)
dgdt = alpha2.pos() * man.fvc.div(phi) / alpha2.ext_max(0.0001)
# Construct interface from alpha1 distribution
interface = man.interfaceProperties(alpha1, U, twoPhaseProperties)
# Construct incompressible turbulence model
turbulence = man.incompressible.turbulenceModel.New(
U, phi, twoPhaseProperties)
return p_rgh, alpha1, alpha2, U, phi, twoPhaseProperties, rho10, rho20, psi1, psi2, pMin, \
gh, ghf, p, rho1, rho2, rho, rhoPhi, dgdt, interface, turbulence