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 _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 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 fun_UEqn( mesh, U, p_rgh, ghf, rho, rhoPhi, turbulence, twoPhaseProperties, pimple ):
muEff = man.surfaceScalarField( ref.word( "muEff" ),
man.surfaceScalarField( twoPhaseProperties.muf(), man.Deps( twoPhaseProperties ) )
+ man.fvc.interpolate( rho * man.volScalarField( turbulence.ext_nut(), man.Deps( turbulence ) ) ) )
UEqn = man.fvm.ddt( rho, U ) + man.fvm.div( rhoPhi, U ) - man.fvm.laplacian( muEff, U ) - ( man.fvc.grad( U ) & man.fvc.grad( muEff ) )
UEqn.relax()
if pimple.momentumPredictor():
ref.solve( UEqn == ref.fvc.reconstruct( ( - ghf * ref.fvc.snGrad( rho ) - ref.fvc.snGrad( p_rgh ) ) * mesh.magSf() ) )
pass
return UEqn
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 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 _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, 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 _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, 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 fun_Ueqn( simple, mesh, rho, U, phi, turbulence, ghf, p_rgh ):
UEqn = man.fvm.div( phi, U ) + man( turbulence.divDevRhoReff( U ), man.Deps( turbulence, U) )
UEqn.relax()
if simple.momentumPredictor():
ref.solve( UEqn == man.fvc.reconstruct( ( ( - ghf * man.fvc.snGrad( rho ) - man.fvc.snGrad( p_rgh ) )
* man.surfaceScalarField( mesh.magSf(), man.Deps( mesh ) ) ) ) )
return UEqn
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 fun_Ueqn(simple, mesh, rho, U, phi, turbulence, ghf, p_rgh):
UEqn = man.fvm.div(phi, U) + man(turbulence.divDevRhoReff(U),
man.Deps(turbulence, U))
UEqn.relax()
if simple.momentumPredictor():
ref.solve(UEqn == man.fvc.reconstruct((
(-ghf * man.fvc.snGrad(rho) - man.fvc.snGrad(p_rgh)) *
man.surfaceScalarField(mesh.magSf(), man.Deps(mesh)))))
return UEqn
def _UEqn(mesh, alpha1, U, p, p_rgh, ghf, rho, rhoPhi, turbulence, g,
twoPhaseProperties, interface, pimple):
muEff = man.surfaceScalarField(
ref.word("muEff"),
man.surfaceScalarField(twoPhaseProperties.muf(),
man.Deps(twoPhaseProperties)) +
man.fvc.interpolate(rho * man.volScalarField(turbulence.ext_nut(),
man.Deps(turbulence))))
UEqn = man.fvm.ddt(rho, U) + man.fvm.div(rhoPhi, U) - man.fvm.laplacian(
muEff, U) - (man.fvc.grad(U) & man.fvc.grad(muEff))
UEqn.relax()
if pimple.momentumPredictor():
ref.solve( UEqn == \
ref.fvc.reconstruct( ( ref.fvc.interpolate( interface.sigmaK() ) * ref.fvc.snGrad( alpha1 ) - ghf * ref.fvc.snGrad( rho ) \
- ref.fvc.snGrad( p_rgh ) ) * mesh.magSf() ) )
pass
return UEqn
def fun_Ueqn(pimple, mesh, rho, U, phi, turbulence, ghf, p_rgh):
# Solve the Momentum equation
UEqn = man.fvm.ddt(rho, U) + man.fvm.div(phi, U) + man.fvVectorMatrix(
turbulence.divDevRhoReff(U()), man.Deps(turbulence, U))
UEqn.relax()
if pimple.momentumPredictor():
ref.solve(UEqn == man.fvc.reconstruct(
(-ghf * man.fvc.snGrad(rho) - man.fvc.snGrad(p_rgh)) *
man.surfaceScalarField(mesh.magSf(), man.Deps(mesh))))
return UEqn
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 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 fun_Ueqn(pimple, mesh, rho, U, phi, turbulence, ghf, p_rgh):
# Solve the Momentum equation
UEqn = (
man.fvm.ddt(rho, U)
+ man.fvm.div(phi, U)
+ man.fvVectorMatrix(turbulence.divDevRhoReff(U()), man.Deps(turbulence, U))
)
UEqn.relax()
if pimple.momentumPredictor():
ref.solve(
UEqn
== man.fvc.reconstruct(
(-ghf * man.fvc.snGrad(rho) - man.fvc.snGrad(p_rgh))
* man.surfaceScalarField(mesh.magSf(), man.Deps(mesh))
)
)
return UEqn
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 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 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 ):
# 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 _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
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() << "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()
Dab = ref.dimensionedScalar( twoPhaseProperties.lookup( ref.word( "Dab" ) ) )
# Read the reciprocal of the turbulent Schmidt number
alphatab = ref.dimensionedScalar( twoPhaseProperties.lookup( ref.word( "alphatab" ) ) )
# Need to store rho for ddt(rho, U)
rho = man.volScalarField ( ref.word( "rho" ), alpha1 * rho1 + ( ref.scalar(1) - alpha1 ) * rho2 )
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 incompressible turbulence model
turbulence = man.incompressible.turbulenceModel.New( U, phi, twoPhaseProperties )
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, alpha1, U, phi, twoPhaseProperties, rho1, rho2, Dab, alphatab, rho, rhoPhi, turbulence, gh, ghf, p, pRefCell, pRefValue
def fun_UEqn( mesh, pimple, U, phi, turbulence, p, rhok, p_rgh, ghf ):
UEqn = man.fvm.ddt( U ) + man.fvm.div(phi, U) + man( turbulence.divDevReff( U ) , man.Deps( U ) )
UEqn.relax()
if pimple.momentumPredictor():
ref.solve( UEqn == man.fvc.reconstruct( ( - ghf * man.fvc.snGrad( rhok ) - man.fvc.snGrad( p_rgh ) ) * man.surfaceScalarField( mesh.magSf(), mesh ) ) )
pass
return UEqn
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):
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() << "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 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
