def readTimeControls_010401_dev( runTime ):
    from Foam.OpenFOAM import Switch, word, readScalar, GREAT
    
    adjustTimeStep = Switch( runTime.controlDict().lookup( word( "adjustTimeStep" ) ) )
    maxCo = readScalar( runTime.controlDict().lookup( word( "maxCo" ) ) )
    
    maxDeltaT = GREAT
    if runTime.controlDict().found( word( "maxDeltaT" ) ):
       maxDeltaT = readScalar( runTime.controlDict().lookup( word( "maxDeltaT" ) ) )
       pass

    return adjustTimeStep, maxCo, maxDeltaT
예제 #2
0
def readTimeControls_010401_dev( runTime ):
    from Foam.OpenFOAM import Switch, word, readScalar, GREAT
    
    adjustTimeStep = Switch( runTime.controlDict().lookup( word( "adjustTimeStep" ) ) )
    maxCo = readScalar( runTime.controlDict().lookup( word( "maxCo" ) ) )
    
    maxDeltaT = GREAT
    if runTime.controlDict().found( word( "maxDeltaT" ) ):
       maxDeltaT = readScalar( runTime.controlDict().lookup( word( "maxDeltaT" ) ) )
       pass

    return adjustTimeStep, maxCo, maxDeltaT
예제 #3
0
 def _init__with_2_param( self, *args ):
     if len(args) != 2:
        raise AssertionError( "len( args ) != 2" )
     argc = 0
     
     from Foam.finiteVolume import fvMesh
     try:
         fvMesh.ext_isinstance( args[ argc ] )
     except TypeError:
         raise AssertionError( "args[ argc ].__class__ != fvMesh" )
     mesh = args[ argc ]; argc +=1
     
     from Foam.OpenFOAM import dictionary
     try:
         dictionary.ext_isinstance( args[ argc ] )
     except TypeError:
         raise AssertionError( "args[ argc ].__class__ != dictionary" )
     dict_ = args[ argc ]
     PtrList_TypeBase.__init__( self )
     from Foam.OpenFOAM import polyPatchID, word, readLabel, readScalar
     self.patchID_ = polyPatchID( dict_.lookup( word( "patch" ) ), mesh.boundaryMesh() )
     self.faceIndex_ = readLabel( dict_.lookup( word( "face" ) ) )
     self.dir_ = self.getDir( dict_ )
     self.value_ = readScalar( dict_.lookup( word( "value" ) ) )
     self.checkPatchFace(mesh)
예제 #4
0
    def _init__with_2_param(self, *args):
        if len(args) != 2:
            raise AssertionError("len( args ) != 2")
        argc = 0

        from Foam.finiteVolume import fvMesh
        try:
            fvMesh.ext_isinstance(args[argc])
        except TypeError:
            raise AssertionError("args[ argc ].__class__ != fvMesh")
        mesh = args[argc]
        argc += 1

        from Foam.OpenFOAM import dictionary
        try:
            dictionary.ext_isinstance(args[argc])
        except TypeError:
            raise AssertionError("args[ argc ].__class__ != dictionary")
        dict_ = args[argc]
        PtrList_TypeBase.__init__(self)
        from Foam.OpenFOAM import polyPatchID, word, readLabel, readScalar
        self.patchID_ = polyPatchID(dict_.lookup(word("patch")),
                                    mesh.boundaryMesh())
        self.faceIndex_ = readLabel(dict_.lookup(word("face")))
        self.dir_ = self.getDir(dict_)
        self.value_ = readScalar(dict_.lookup(word("value")))
        self.checkPatchFace(mesh)
def readTimeControls_010600_dev( runTime ):
    from Foam.OpenFOAM import Switch, word, readScalar, GREAT
    
    adjustTimeStep = Switch( runTime.controlDict().lookup( word( "adjustTimeStep" ) ) )
    maxCo = readScalar( runTime.controlDict().lookup( word( "maxCo" ) ) )
    
    maxDeltaT = runTime.controlDict().lookupOrDefault( word( "maxDeltaT" ), GREAT, 0, 1 )

    return adjustTimeStep, maxCo, maxDeltaT
예제 #6
0
def readTimeControls_010600_dev( runTime ):
    from Foam.OpenFOAM import Switch, word, readScalar, GREAT
    
    adjustTimeStep = Switch( runTime.controlDict().lookup( word( "adjustTimeStep" ) ) )
    maxCo = readScalar( runTime.controlDict().lookup( word( "maxCo" ) ) )
    
    maxDeltaT = runTime.controlDict().lookupOrDefault( word( "maxDeltaT" ), GREAT, 0, 1 )

    return adjustTimeStep, maxCo, maxDeltaT
예제 #7
0
def readStressedFoamControls( mesh):
    from Foam.OpenFOAM import word
    stressControl = mesh.solutionDict().subDict( word( "stressedFoam" ) )
    
    from Foam.OpenFOAM import readInt
    nCorr = readInt( stressControl.lookup( word( "nCorrectors" ) ) )
    
    from Foam.OpenFOAM import readScalar
    convergenceTolerance = readScalar(stressControl.lookup( word( "U" ) ) )
    
    from materialModels.componentReference import componentReference
#    from Foam.template import PtrList
#    cr = PtrList( componentReference )( stressControl.lookup( word( "componentReference" ) ), componentReference.iNew(mesh) )
    
    from Foam.template import PtrList
    cr = PtrList( stressControl.lookup( word( "componentReference" ) ), componentReference.iNew(mesh) )
    
    return stressControl, nCorr, convergenceTolerance, cr
예제 #8
0
def readStressedFoamControls(mesh):
    from Foam.OpenFOAM import word
    stressControl = mesh.solutionDict().subDict(word("stressedFoam"))

    from Foam.OpenFOAM import readInt
    nCorr = readInt(stressControl.lookup(word("nCorrectors")))

    from Foam.OpenFOAM import readScalar
    convergenceTolerance = readScalar(stressControl.lookup(word("U")))

    from materialModels.componentReference import componentReference
    #    from Foam.template import PtrList
    #    cr = PtrList( componentReference )( stressControl.lookup( word( "componentReference" ) ), componentReference.iNew(mesh) )

    from Foam.template import PtrList
    cr = PtrList(stressControl.lookup(word("componentReference")),
                 componentReference.iNew(mesh))

    return stressControl, nCorr, convergenceTolerance, cr
예제 #9
0
def alphaCourantNo( runTime, mesh, alpha1, phi ):
    from Foam.OpenFOAM import readScalar, word
    maxAlphaCo = readScalar( runTime.controlDict().lookup(word( "maxAlphaCo" ) ) )
    
    alphaCoNum = 0.0
    meanAlphaCoNum = 0.0
    
    if mesh.nInternalFaces():
       from Foam import fvc
       alphaf = fvc.interpolate(alpha1)

       SfUfbyDelta = (alphaf - 0.01).pos() * ( 0.99 - alphaf ).pos() * mesh.deltaCoeffs() * phi.mag()
       alphaCoNum = ( SfUfbyDelta/mesh.magSf() ).ext_max().value() * runTime.deltaT().value()
       meanAlphaCoNum = ( SfUfbyDelta.sum() / mesh.magSf().sum() ).value() * runTime.deltaT().value()
       pass
    
    from Foam.OpenFOAM import ext_Info, nl
    ext_Info() << "Interface Courant Number mean: " << meanAlphaCoNum << " max: " << alphaCoNum << nl
    
    return maxAlphaCo, alphaCoNum, meanAlphaCoNum
예제 #10
0
def main_standalone(argc, argv):

    from Foam.OpenFOAM.include import setRootCase
    args = setRootCase(argc, argv)

    from Foam.OpenFOAM.include import createTime
    runTime = createTime(args)

    from Foam.OpenFOAM.include import createMesh
    mesh = createMesh(runTime)

    thermodynamicProperties, R, Cv, Cp, gamma, Pr = readThermodynamicProperties(
        runTime, mesh)

    p, T, psi, pbf, rhoBoundaryTypes, rho, U, Ubf, rhoUboundaryTypes, \
    rhoU, Tbf, rhoEboundaryTypes, rhoE, phi, phiv, rhoU, fields, magRhoU, H = _createFields( runTime, mesh, R, Cv )

    from Foam.OpenFOAM import ext_Info, nl
    ext_Info() << "\nStarting time loop\n" << nl

    while runTime.loop():
        ext_Info() << "Time = " << runTime.value() << nl << nl

        from Foam.finiteVolume.cfdTools.general.include import readPISOControls
        piso, nCorr, nNonOrthCorr, momentumPredictor, transonic, nOuterCorr = readPISOControls(
            mesh)

        from Foam.OpenFOAM import readScalar, word
        HbyAblend = readScalar(piso.lookup(word("HbyAblend")))

        from Foam.finiteVolume.cfdTools.general.include import readTimeControls
        adjustTimeStep, maxCo, maxDeltaT = readTimeControls(runTime)

        CoNum = (mesh.deltaCoeffs() * phiv.mag() /
                 mesh.magSf()).ext_max().value() * runTime.deltaT().value()

        ext_Info() << "Max Courant Number = " << CoNum << nl

        from Foam.finiteVolume.cfdTools.general.include import setDeltaT
        runTime = setDeltaT(runTime, adjustTimeStep, maxCo, maxDeltaT, CoNum)

        for outerCorr in range(nOuterCorr):

            magRhoU.ext_assign(rhoU.mag())
            H.ext_assign((rhoE + p) / rho)

            from Foam.fv import multivariateGaussConvectionScheme_scalar
            mvConvection = multivariateGaussConvectionScheme_scalar(
                mesh, fields, phiv, mesh.divScheme(word("div(phiv,rhoUH)")))

            from Foam.finiteVolume import solve
            from Foam import fvm
            solve(fvm.ddt(rho) + mvConvection.fvmDiv(phiv, rho))

            tmp = mvConvection.interpolationScheme()()(magRhoU)

            rhoUWeights = tmp.ext_weights(magRhoU)

            from Foam.finiteVolume import weighted_vector
            rhoUScheme = weighted_vector(rhoUWeights)
            from Foam import fv, fvc
            rhoUEqn = fvm.ddt(rhoU) + fv.gaussConvectionScheme_vector(
                mesh, phiv, rhoUScheme).fvmDiv(phiv, rhoU)
            solve(rhoUEqn == -fvc.grad(p))

            solve(
                fvm.ddt(rhoE) + mvConvection.fvmDiv(phiv, rhoE) ==
                -mvConvection.fvcDiv(phiv, p))

            T.ext_assign((rhoE - 0.5 * rho * (rhoU / rho).magSqr()) / Cv / rho)
            psi.ext_assign(1.0 / (R * T))
            p.ext_assign(rho / psi)

            for corr in range(nCorr):
                rrhoUA = 1.0 / rhoUEqn.A()
                from Foam.finiteVolume import surfaceScalarField
                rrhoUAf = surfaceScalarField(word("rrhoUAf"),
                                             fvc.interpolate(rrhoUA))
                HbyA = rrhoUA * rhoUEqn.H()

                from Foam.finiteVolume import LimitedScheme_vector_MUSCLLimiter_NVDTVD_limitFuncs_magSqr
                from Foam.OpenFOAM import IStringStream, word
                HbyAWeights = HbyAblend * mesh.weights() + ( 1.0 - HbyAblend ) * \
                              LimitedScheme_vector_MUSCLLimiter_NVDTVD_limitFuncs_magSqr( mesh, phi, IStringStream( "HbyA" )() ).weights( HbyA )

                from Foam.finiteVolume import surfaceInterpolationScheme_vector
                phi.ext_assign( ( surfaceInterpolationScheme_vector.ext_interpolate(HbyA, HbyAWeights) & mesh.Sf() ) \
                                  + HbyAblend * fvc.ddtPhiCorr( rrhoUA, rho, rhoU, phi ) )

                p.ext_boundaryField().updateCoeffs()

                phiGradp = rrhoUAf * mesh.magSf() * fvc.snGrad(p)

                phi.ext_assign(phi - phiGradp)

                resetPhiPatches(phi, rhoU, mesh)
                rhof = mvConvection.interpolationScheme()()(rho).interpolate(
                    rho)

                phiv.ext_assign(phi / rhof)

                pEqn = fvm.ddt(psi, p) + mvConvection.fvcDiv(
                    phiv, rho) + fvc.div(phiGradp) - fvm.laplacian(rrhoUAf, p)

                pEqn.solve()
                phi.ext_assign(phi + phiGradp + pEqn.flux())
                rho.ext_assign(psi * p)

                rhof.ext_assign(
                    mvConvection.interpolationScheme()()(rho).interpolate(rho))
                phiv.ext_assign(phi / rhof)

                rhoU.ext_assign(HbyA - rrhoUA * fvc.grad(p))
                rhoU.correctBoundaryConditions()

                pass
            pass

        U.ext_assign(rhoU / rho)

        runTime.write()

        ext_Info() << "ExecutionTime = " << runTime.elapsedCpuTime() << " s" << \
              "  ClockTime = " << runTime.elapsedClockTime() << " s" << nl << nl
        pass

    ext_Info() << "End\n"

    import os
    return os.EX_OK
예제 #11
0
def main_standalone( argc, argv ):

    from Foam.OpenFOAM.include import setRootCase
    args = setRootCase( argc, argv )

    from Foam.OpenFOAM.include import createTime
    runTime = createTime( args )

    from Foam.OpenFOAM.include import createMesh
    mesh = createMesh( runTime )
    
    thermodynamicProperties, R, Cv, Cp, gamma, Pr = readThermodynamicProperties( runTime, mesh )
    
    p, T, psi, pbf, rhoBoundaryTypes, rho, U, Ubf, rhoUboundaryTypes, \
    rhoU, Tbf, rhoEboundaryTypes, rhoE, phi, phiv, rhoU, fields, magRhoU, H = _createFields( runTime, mesh, R, Cv )
    
    from Foam.OpenFOAM import ext_Info, nl
    ext_Info() << "\nStarting time loop\n" << nl
    
    while runTime.loop():
        ext_Info() << "Time = " << runTime.value() << nl << nl
        
        from Foam.finiteVolume.cfdTools.general.include import readPISOControls
        piso, nCorr, nNonOrthCorr, momentumPredictor, transonic, nOuterCorr = readPISOControls( mesh )
        
        from Foam.OpenFOAM import readScalar, word
        HbyAblend = readScalar( piso.lookup( word( "HbyAblend" ) ) )
        
        from Foam.finiteVolume.cfdTools.general.include import readTimeControls
        adjustTimeStep, maxCo, maxDeltaT = readTimeControls( runTime )
    
        CoNum = ( mesh.deltaCoeffs() * phiv.mag() / mesh.magSf() ).ext_max().value() * runTime.deltaT().value()
        
        ext_Info() << "Max Courant Number = " << CoNum << nl
        
        from Foam.finiteVolume.cfdTools.general.include import setDeltaT
        runTime = setDeltaT( runTime, adjustTimeStep, maxCo, maxDeltaT, CoNum )

        for outerCorr in range( nOuterCorr):

            magRhoU.ext_assign( rhoU.mag() )
            H.ext_assign( ( rhoE + p ) / rho )
            
            from Foam.fv import multivariateGaussConvectionScheme_scalar
            mvConvection = multivariateGaussConvectionScheme_scalar( mesh, fields, phiv, mesh.divScheme( word( "div(phiv,rhoUH)" ) ) )
            
            from Foam.finiteVolume import solve
            from Foam import fvm
            solve( fvm.ddt( rho ) + mvConvection.fvmDiv( phiv, rho ) )
            
            tmp = mvConvection.interpolationScheme()()( magRhoU )
            
            rhoUWeights = tmp.ext_weights( magRhoU )
            
            from Foam.finiteVolume import weighted_vector
            rhoUScheme = weighted_vector(rhoUWeights)
            from Foam import fv, fvc
            rhoUEqn = fvm.ddt(rhoU) + fv.gaussConvectionScheme_vector( mesh, phiv, rhoUScheme ).fvmDiv( phiv, rhoU )
            solve( rhoUEqn == -fvc.grad( p ) )

            solve( fvm.ddt( rhoE ) + mvConvection.fvmDiv( phiv, rhoE ) == - mvConvection.fvcDiv( phiv, p ) )

            T.ext_assign( (rhoE - 0.5 * rho * ( rhoU / rho ).magSqr() ) / Cv / rho )
            psi.ext_assign( 1.0 / ( R * T ) )
            p.ext_assign( rho / psi )
            
            for corr in range( nCorr ):
                rrhoUA = 1.0 / rhoUEqn.A()
                from Foam.finiteVolume import surfaceScalarField
                rrhoUAf = surfaceScalarField( word( "rrhoUAf" ), fvc.interpolate( rrhoUA ) )
                HbyA = rrhoUA * rhoUEqn.H()
                
                from Foam.finiteVolume import LimitedScheme_vector_MUSCLLimiter_NVDTVD_limitFuncs_magSqr
                from Foam.OpenFOAM import IStringStream, word
                HbyAWeights = HbyAblend * mesh.weights() + ( 1.0 - HbyAblend ) * \
                              LimitedScheme_vector_MUSCLLimiter_NVDTVD_limitFuncs_magSqr( mesh, phi, IStringStream( "HbyA" )() ).weights( HbyA )
                
                from Foam.finiteVolume import surfaceInterpolationScheme_vector
                phi.ext_assign( ( surfaceInterpolationScheme_vector.ext_interpolate(HbyA, HbyAWeights) & mesh.Sf() ) \
                                  + HbyAblend * fvc.ddtPhiCorr( rrhoUA, rho, rhoU, phi ) )
                
                p.ext_boundaryField().updateCoeffs()
                
                phiGradp = rrhoUAf * mesh.magSf() * fvc.snGrad( p )
                
                phi.ext_assign( phi - phiGradp )
                
                resetPhiPatches( phi, rhoU, mesh )
                rhof = mvConvection.interpolationScheme()()(rho).interpolate(rho)

                phiv.ext_assign( phi/rhof )
                
                pEqn = fvm.ddt( psi, p ) + mvConvection.fvcDiv( phiv, rho ) + fvc.div( phiGradp ) - fvm.laplacian( rrhoUAf, p )
                
                pEqn.solve()
                phi.ext_assign( phi + phiGradp + pEqn.flux() )
                rho.ext_assign( psi * p )
                
                rhof.ext_assign( mvConvection.interpolationScheme()()( rho ).interpolate(rho) )
                phiv.ext_assign( phi / rhof )
                
                rhoU.ext_assign( HbyA - rrhoUA * fvc.grad(p) )
                rhoU.correctBoundaryConditions()

                pass
            pass
        
        U.ext_assign( rhoU / rho )

        runTime.write()

        ext_Info() << "ExecutionTime = " << runTime.elapsedCpuTime() << " s" << \
              "  ClockTime = " << runTime.elapsedClockTime() << " s" << nl << nl
        pass

    ext_Info() << "End\n"

    import os
    return os.EX_OK
예제 #12
0
def _createFields(runTime, mesh, g):
    from Foam.OpenFOAM import ext_Info, nl
    from Foam.OpenFOAM import IOdictionary, IOobject, word, fileName
    from Foam.finiteVolume import volScalarField

    ext_Info() << "Reading field pd\n" << nl
    pd = volScalarField(
        IOobject(word("pd"), fileName(runTime.timeName()), mesh,
                 IOobject.MUST_READ, IOobject.AUTO_WRITE), mesh)

    ext_Info() << "Reading field alpha1\n" << nl
    alpha1 = volScalarField(
        IOobject(word("alpha1"), fileName(runTime.timeName()), mesh,
                 IOobject.MUST_READ, IOobject.AUTO_WRITE), mesh)

    ext_Info() << "Reading field U\n" << nl
    from Foam.finiteVolume import volVectorField
    U = volVectorField(
        IOobject(word("U"), fileName(runTime.timeName()), mesh,
                 IOobject.MUST_READ, IOobject.AUTO_WRITE), mesh)

    from Foam.finiteVolume.cfdTools.incompressible import createPhi
    phi = createPhi(runTime, mesh, U)

    ext_Info() << "Reading transportProperties\n" << nl
    from Foam.transportModels import twoPhaseMixture
    twoPhaseProperties = twoPhaseMixture(U, phi, word("alpha1"))

    rho1 = twoPhaseProperties.rho1()
    rho2 = twoPhaseProperties.rho2()

    # Need to store rho for ddt(rho, U)
    rho = volScalarField(
        IOobject(word("rho"), fileName(runTime.timeName()), mesh,
                 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.
    from Foam.finiteVolume import surfaceScalarField
    rhoPhi = surfaceScalarField(
        IOobject(word("rho*phi"), fileName(runTime.timeName()), mesh,
                 IOobject.NO_READ, IOobject.NO_WRITE), rho1 * phi)

    ext_Info() << "Calculating field g.h\n" << nl
    gh = volScalarField(word("gh"), g & mesh.C())
    ghf = surfaceScalarField(word("gh"), g & mesh.Cf())

    p = volScalarField(
        IOobject(word("p"), fileName(runTime.timeName()), mesh,
                 IOobject.NO_READ, IOobject.AUTO_WRITE), pd + rho * gh)

    pdRefCell = 0
    pdRefValue = 0.0

    from Foam.finiteVolume import setRefCell
    pdRefCell, pdRefValue = setRefCell(
        pd,
        mesh.solutionDict().subDict(word("PISO")), pdRefCell, pdRefValue)

    pRefValue = 0.0

    if pd.needReference():
        from Foam.OpenFOAM import readScalar, dimensionedScalar
        from Foam.finiteVolume import getRefCellValue
        pRefValue = readScalar(mesh.solutionDict().subDict(
            word("PISO")).lookup(word("pRefValue")))
        p.ext_assign(
            p + dimensionedScalar(word("p"), p.dimensions(), pRefValue -
                                  getRefCellValue(p, pdRefCell)))
        pass

    # Construct interface from alpha1 distribution
    from Foam.transportModels import interfaceProperties
    interface = interfaceProperties(alpha1, U, twoPhaseProperties)

    # Construct incompressible turbulence model
    from Foam import incompressible
    turbulence = incompressible.turbulenceModel.New(U, phi, twoPhaseProperties)

    return p, pd, gh, ghf, alpha1, U, phi, rho1, rho2, rho, rhoPhi, twoPhaseProperties, pdRefCell, pdRefValue, pRefValue, interface, turbulence
예제 #13
0
def _createFields(runTime, mesh, g):
    from Foam.OpenFOAM import ext_Info, nl
    from Foam.OpenFOAM import IOdictionary, IOobject, word, fileName
    from Foam.finiteVolume import volScalarField

    ext_Info() << "Reading field pd\n" << nl
    pd = volScalarField(
        IOobject(word("pd"), fileName(runTime.timeName()), mesh, IOobject.MUST_READ, IOobject.AUTO_WRITE), mesh
    )

    ext_Info() << "Reading field alpha1\n" << nl
    alpha1 = volScalarField(
        IOobject(word("alpha1"), fileName(runTime.timeName()), mesh, IOobject.MUST_READ, IOobject.AUTO_WRITE), mesh
    )

    ext_Info() << "Reading field U\n" << nl
    from Foam.finiteVolume import volVectorField

    U = volVectorField(
        IOobject(word("U"), fileName(runTime.timeName()), mesh, IOobject.MUST_READ, IOobject.AUTO_WRITE), mesh
    )

    from Foam.finiteVolume.cfdTools.incompressible import createPhi

    phi = createPhi(runTime, mesh, U)

    ext_Info() << "Reading transportProperties\n" << nl
    from Foam.transportModels import twoPhaseMixture

    twoPhaseProperties = twoPhaseMixture(U, phi, word("alpha1"))

    rho1 = twoPhaseProperties.rho1()
    rho2 = twoPhaseProperties.rho2()

    # Need to store rho for ddt(rho, U)
    rho = volScalarField(
        IOobject(word("rho"), fileName(runTime.timeName()), mesh, 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.
    from Foam.finiteVolume import surfaceScalarField

    rhoPhi = surfaceScalarField(
        IOobject(word("rho*phi"), fileName(runTime.timeName()), mesh, IOobject.NO_READ, IOobject.NO_WRITE), rho1 * phi
    )

    ext_Info() << "Calculating field g.h\n" << nl
    gh = volScalarField(word("gh"), g & mesh.C())
    ghf = surfaceScalarField(word("gh"), g & mesh.Cf())

    p = volScalarField(
        IOobject(word("p"), fileName(runTime.timeName()), mesh, IOobject.NO_READ, IOobject.AUTO_WRITE), pd + rho * gh
    )

    pdRefCell = 0
    pdRefValue = 0.0

    from Foam.finiteVolume import setRefCell

    pdRefCell, pdRefValue = setRefCell(pd, mesh.solutionDict().subDict(word("PISO")), pdRefCell, pdRefValue)

    pRefValue = 0.0

    if pd.needReference():
        from Foam.OpenFOAM import readScalar, dimensionedScalar
        from Foam.finiteVolume import getRefCellValue

        pRefValue = readScalar(mesh.solutionDict().subDict(word("PISO")).lookup(word("pRefValue")))
        p.ext_assign(p + dimensionedScalar(word("p"), p.dimensions(), pRefValue - getRefCellValue(p, pdRefCell)))
        pass

    # Construct interface from alpha1 distribution
    from Foam.transportModels import interfaceProperties

    interface = interfaceProperties(alpha1, U, twoPhaseProperties)

    # Construct incompressible turbulence model
    from Foam import incompressible

    turbulence = incompressible.turbulenceModel.New(U, phi, twoPhaseProperties)

    return (
        p,
        pd,
        gh,
        ghf,
        alpha1,
        U,
        phi,
        rho1,
        rho2,
        rho,
        rhoPhi,
        twoPhaseProperties,
        pdRefCell,
        pdRefValue,
        pRefValue,
        interface,
        turbulence,
    )