def createFields( runTime, mesh ):
ext_Info() << "Reading field U\n" << nl
from Foam.finiteVolume import volVectorField
from Foam.OpenFOAM import IOobject, fileName, word
U = volVectorField( IOobject( word( "U" ),
fileName( runTime.timeName() ),
mesh,
IOobject.MUST_READ,
IOobject.AUTO_WRITE ),
mesh )
from Foam.finiteVolume import volSymmTensorField
from Foam.OpenFOAM import dimensionedSymmTensor, symmTensor
from Foam.OpenFOAM import dimForce, dimArea
sigma = volSymmTensorField( IOobject( word( "sigma" ),
fileName( runTime.timeName() ),
mesh,
IOobject.READ_IF_PRESENT,
IOobject.AUTO_WRITE ),
mesh,
dimensionedSymmTensor( word( "zero" ), dimForce/dimArea, symmTensor.zero)
)
from materialModels.rheologyModel import rheologyModel
rheology = rheologyModel( sigma )
return U, sigma, rheology
def _createFields(runTime, mesh):
from Foam.OpenFOAM import ext_Info, nl
ext_Info() << "Reading thermophysical properties\n" << nl
from Foam.thermophysicalModels import basicPsiThermo, autoPtr_basicPsiThermo
thermo = basicPsiThermo.New(mesh)
p = thermo.p()
e = thermo.e()
psi = thermo.psi()
rho = thermo.rho()
from Foam.OpenFOAM import IOdictionary, IOobject, word, fileName
from Foam.finiteVolume import volScalarField
rho = volScalarField(
IOobject(word("rho"), fileName(runTime.timeName()), mesh), rho())
ext_Info() << "Reading field U\n" << nl
from Foam.finiteVolume import volVectorField
U = volVectorField(
IOobject(word("U"), fileName(runTime.timeName()), mesh,
IOobject.MUST_READ, IOobject.AUTO_WRITE), mesh)
from Foam.finiteVolume.cfdTools.compressible import compressibleCreatePhi
phi = compressibleCreatePhi(runTime, mesh, rho, U)
ext_Info() << "Creating turbulence model\n" << nl
from Foam import compressible
turbulence = compressible.turbulenceModel.New(rho, U, phi, thermo())
return p, e, psi, rho, U, phi, turbulence, thermo
def _createFields( runTime, mesh ):
from Foam.OpenFOAM import ext_Info, nl
from Foam.OpenFOAM import IOdictionary, IOobject, word, fileName
from Foam.finiteVolume import volScalarField
ext_Info() << "Reading field T\n" << nl
T = volScalarField( IOobject( word( "T" ),
fileName( runTime.timeName() ),
mesh,
IOobject.MUST_READ,
IOobject.AUTO_WRITE ),
mesh )
ext_Info() << "Reading transportProperties\n" << nl
transportProperties = IOdictionary( IOobject( word( "transportProperties" ),
fileName( runTime.constant() ),
mesh,
IOobject.MUST_READ,
IOobject.NO_WRITE ) )
ext_Info() << "Reading diffusivity DT\n" << nl
from Foam.OpenFOAM import dimensionedScalar
DT = dimensionedScalar( transportProperties.lookup( word( "DT" ) ) )
return T, transportProperties, DT
def _createFields( runTime, mesh, rhoO, psi ):
from Foam.OpenFOAM import ext_Info, nl
ext_Info() << "Reading field p\n" << nl
from Foam.finiteVolume import volScalarField
from Foam.OpenFOAM import IOdictionary, IOobject, word, fileName
p = volScalarField( IOobject( word( "p" ),
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 )
rho = volScalarField( IOobject( word( "rho" ),
fileName( runTime.timeName() ),
mesh,
IOobject.NO_READ,
IOobject.AUTO_WRITE ),
rhoO + psi * p )
from Foam.finiteVolume.cfdTools.compressible import compressibleCreatePhi
phi = compressibleCreatePhi( runTime, mesh, rho, U )
return p, U, rho, phi
def compressibleCreatePhi(runTime, mesh, rhoU):
from Foam.OpenFOAM import IOobject, word, fileName
phiHeader = IOobject(word("phi"), fileName(runTime.timeName()), mesh,
IOobject.NO_READ)
from Foam.OpenFOAM import ext_Info, nl
if phiHeader.headerOk():
ext_Info() << "Reading face flux field phi\n" << nl
from Foam.finiteVolume import surfaceScalarField
phi = surfaceScalarField(
IOobject(word("phi"), fileName(runTime.timeName()), mesh,
IOobject.MUST_READ, IOobject.AUTO_WRITE), mesh)
pass
else:
ext_Info() << "Calculating face flux field phi\n" << nl
from Foam.OpenFOAM import wordList
from Foam.finiteVolume import calculatedFvPatchScalarField
phiTypes = wordList(2, calculatedFvPatchScalarField.typeName)
from Foam.finiteVolume import surfaceScalarField, linearInterpolate
phi = surfaceScalarField(
IOobject(word("phi"), fileName(runTime.timeName()), mesh,
IOobject.NO_READ, IOobject.AUTO_WRITE),
linearInterpolate(rhoU) & mesh.Sf(), phiTypes)
pass
return phiHeader, phi, phiTypes
def write( runTime, mesh, T ):
if runTime.outputTime():
from Foam import fvc
gradT = fvc.grad(T)
from Foam.OpenFOAM import IOdictionary, IOobject, word, fileName
from Foam.finiteVolume import volScalarField
from Foam.OpenFOAM import vector
gradTx = volScalarField( IOobject( word( "gradTx" ),
fileName( runTime.timeName() ),
mesh,
IOobject.NO_READ,
IOobject.AUTO_WRITE ),
gradT.component( vector.X ) )
gradTy = volScalarField( IOobject( word( "gradTy" ),
fileName( runTime.timeName() ),
mesh,
IOobject.NO_READ,
IOobject.AUTO_WRITE ),
gradT.component( vector.Y ) )
gradTz = volScalarField( IOobject( word( "gradTz" ),
fileName( runTime.timeName() ),
mesh,
IOobject.NO_READ,
IOobject.AUTO_WRITE ),
gradT.component( vector.Z ) )
runTime.write()
pass
def createFluidMeshes( rp, runTime ) :
from Foam.finiteVolume import fvMesh, PtrList_fvMesh
fluidRegions = PtrList_fvMesh( rp.fluidRegionNames.size() )
from Foam.OpenFOAM import word, fileName, IOobject
for index in range( rp.fluidRegionNames.size() ) :
from Foam.OpenFOAM import ext_Info, nl
ext_Info()<< "Create fluid mesh for region " << rp.fluidRegionNames[ index ] \
<< " for time = " << runTime.timeName() << nl << nl
mesh = fvMesh( IOobject( rp.fluidRegionNames[ index ],
fileName( runTime.timeName() ),
runTime,
IOobject.MUST_READ ) )
fluidRegions.ext_set( index, mesh )
# Force calculation of geometric properties to prevent it being done
# later in e.g. some boundary evaluation
# (void)fluidRegions[i].weights();
# (void)fluidRegions[i].deltaCoeffs();
from Foam.OpenFOAM import IOdictionary, autoPtr_IOdictionary
# Attach environmental properties to each region
environmentalProperties = autoPtr_IOdictionary( IOdictionary( IOobject( word( "environmentalProperties" ),
fileName( runTime.constant() ),
fluidRegions[ index ],
IOobject.MUST_READ,
IOobject.NO_WRITE ) ) )
environmentalProperties.ptr().store()
return fluidRegions
def _createFields(runTime, mesh):
from Foam.OpenFOAM import ext_Info, nl
from Foam.OpenFOAM import IOdictionary, IOobject, word, fileName
from Foam.finiteVolume import volScalarField
ext_Info() << "Reading field p\n" << nl
p = volScalarField(
IOobject(word("p"), 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)
from Foam.transportModels import singlePhaseTransportModel
fluid = singlePhaseTransportModel(U, phi)
pRefCell = 0
pRefValue = 0.0
from Foam.finiteVolume import setRefCell
pRefCell, pRefValue = setRefCell(p, mesh.solutionDict().subDict(word("PISO")), pRefCell, pRefValue)
return p, U, phi, fluid, pRefCell, pRefValue
def _createFields(runTime, mesh):
from Foam.OpenFOAM import ext_Info, nl
from Foam.OpenFOAM import IOdictionary, IOobject, word, fileName
from Foam.finiteVolume import volScalarField
ext_Info() << "Reading field p\n" << nl
p = volScalarField(
IOobject(word("p"), 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)
pRefCell = 0
pRefValue = 0.0
from Foam.finiteVolume import setRefCell
pRefCell, pRefValue = setRefCell(p,
mesh.solutionDict().subDict(word("PISO")),
pRefCell, pRefValue)
from Foam.transportModels import singlePhaseTransportModel
laminarTransport = singlePhaseTransportModel(U, phi)
from Foam import incompressible
turbulence = incompressible.turbulenceModel.New(U, phi, laminarTransport)
return p, U, phi, turbulence, pRefCell, pRefValue, laminarTransport
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 thermophysical properties\n" << nl
ext_Info() << "Reading field T\n" << nl
T = volScalarField( IOobject( word( "T" ),
fileName( runTime.timeName() ),
mesh,
IOobject.MUST_READ,
IOobject.AUTO_WRITE ),
mesh )
ext_Info() << "Reading field p\n" << nl
p = volScalarField( IOobject( word( "p" ),
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 )
laminarTransport, beta, TRef,Pr, Prt = readTransportProperties( U, phi )
ext_Info() << "Creating turbulence model\n" << nl
from Foam import incompressible
turbulence = incompressible.RASModel.New( U, phi, laminarTransport )
ext_Info() << "Calculating field beta*(g.h)\n" << nl
from Foam.finiteVolume import surfaceScalarField
betaghf = surfaceScalarField( word( "betagh" ), beta * ( g & mesh.Cf() ) )
pRefCell = 0
pRefValue = 0.0
from Foam.finiteVolume import setRefCell
pRefCell, pRefValue = setRefCell( p, mesh.solutionDict().subDict( word( "SIMPLE" ) ), pRefCell, pRefValue )
# Kinematic density for buoyancy force
rhok = volScalarField( IOobject( word( "rhok" ),
fileName( runTime.timeName() ),
mesh ),
1.0 - beta * ( T - TRef ) )
return T, p, U, phi, laminarTransport, beta, TRef,Pr, Prt, turbulence, betaghf, pRefCell, pRefValue, rhok
def create_fields( runTime, mesh, g ):
from Foam.OpenFOAM import ext_Info, nl
ext_Info() << "Reading thermophysical properties\n" << nl
from Foam.thermophysicalModels import basicRhoThermo
thermo = basicRhoThermo.New( mesh )
from Foam.OpenFOAM import IOobject, word, fileName
from Foam.finiteVolume import volScalarField
rho = volScalarField( IOobject( word( "rho" ),
fileName( runTime.timeName() ),
mesh,
IOobject.NO_READ,
IOobject.NO_WRITE ),
thermo.rho() )
p = thermo.p()
h = thermo.h()
psi = thermo.psi()
ext_Info() << "Reading field U\n" << nl
from Foam.finiteVolume import volVectorField
U = volVectorField( IOobject( word( "U" ),
fileName( runTime.timeName() ),
mesh,
IOobject.MUST_READ,
IOobject.AUTO_WRITE ),
mesh )
from Foam.finiteVolume.cfdTools.compressible import compressibleCreatePhi
phi = compressibleCreatePhi( runTime, mesh, rho, U )
ext_Info() << "Creating turbulence model\n" << nl
from Foam import compressible
turbulence = compressible.turbulenceModel.New( rho, U, phi, thermo() )
ext_Info() << "Calculating field g.h\n" << nl
gh = volScalarField( word( "gh" ), g & mesh.C() )
from Foam.finiteVolume import surfaceScalarField
ghf = surfaceScalarField( word( "ghf" ), g & mesh.Cf() )
ext_Info() << "Reading field p_rgh\n" << nl
p_rgh = volScalarField( IOobject( word( "p_rgh" ),
fileName( runTime.timeName() ),
mesh,
IOobject.MUST_READ,
IOobject.AUTO_WRITE ),
mesh )
# Force p_rgh to be consistent with p
p_rgh.ext_assign( p - rho * gh )
ext_Info() << "Creating field DpDt\n" << nl
from Foam import fvc
DpDt = volScalarField( word( "DpDt" ), fvc.DDt( surfaceScalarField( word( "phiU" ), phi / fvc.interpolate( rho ) ), p ) )
return thermo, p, rho, h, psi, U, phi, turbulence, gh, ghf, p_rgh, DpDt
def create_fields( runTime, mesh ):
from Foam.OpenFOAM import ext_Info, nl
ext_Info() << "Reading thermophysical properties\n" << nl
from Foam.thermophysicalModels import basicPsiThermo, autoPtr_basicPsiThermo
thermo = basicPsiThermo.New( mesh )
p = thermo.p()
h = thermo.h()
psi = thermo.psi()
from Foam.OpenFOAM import IOobject, word, fileName
from Foam.finiteVolume import volScalarField
rho = volScalarField( IOobject( word( "rho" ),
fileName( runTime.timeName() ),
mesh,
IOobject.READ_IF_PRESENT,
IOobject.AUTO_WRITE ),
thermo.rho() )
ext_Info() << "Reading field U\n" << nl
from Foam.finiteVolume import volVectorField
U = volVectorField( IOobject( word( "U" ),
fileName( runTime.timeName() ),
mesh,
IOobject.MUST_READ,
IOobject.AUTO_WRITE ),
mesh )
from Foam.finiteVolume.cfdTools.compressible import compressibleCreatePhi
phi = compressibleCreatePhi( runTime, mesh, rho, U )
from Foam.OpenFOAM import dimensionedScalar
pMin = dimensionedScalar( mesh.solutionDict().subDict( word( "PIMPLE" ) ).lookup( word( "pMin" ) ) )
ext_Info() << "Creating turbulence model\n" << nl
from Foam import compressible
turbulence = compressible.turbulenceModel.New( rho, U, phi, thermo() )
# initialMass = fvc.domainIntegrate(rho)
ext_Info() << "Creating field DpDt\n" << nl
from Foam import fvc
from Foam.finiteVolume import surfaceScalarField
DpDt = fvc.DDt( surfaceScalarField( word( "phiU" ), phi / fvc.interpolate( rho ) ), p )
from Foam.finiteVolume import MRFZones
mrfZones = MRFZones( mesh )
mrfZones.correctBoundaryVelocity( U )
from Foam.finiteVolume import porousZones
pZones = porousZones( mesh )
from Foam.OpenFOAM import Switch
pressureImplicitPorosity = Switch( False )
return thermo, turbulence, p, h, psi, rho, U, phi, pMin, DpDt, mrfZones, pZones, pressureImplicitPorosity
def create_fields( runTime, mesh ):
from Foam.OpenFOAM import ext_Info, nl
ext_Info() << "Reading field p\n" << nl
from Foam.OpenFOAM import IOobject, word, fileName
from Foam.finiteVolume import volScalarField
p = volScalarField( IOobject( word( "p" ),
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 )
pRefCell = 0
pRefValue = 0.0
from Foam.finiteVolume import setRefCell
pRefCell, pRefValue = setRefCell( p, mesh.solutionDict().subDict( word( "SIMPLE" ) ), pRefCell, pRefValue )
from Foam.transportModels import singlePhaseTransportModel
laminarTransport = singlePhaseTransportModel( U, phi )
from Foam import incompressible
turbulence = incompressible.RASModel.New( U, phi, laminarTransport )
from Foam.finiteVolume import porousZones
pZones = porousZones( mesh )
from Foam.OpenFOAM import Switch
pressureImplicitPorosity = Switch( False )
nUCorr = 0
if pZones.size():
# nUCorrectors for pressureImplicitPorosity
if (mesh.solutionDict().subDict( word( "SIMPLE" ) ).found( word( "nUCorrectors" ) ) ) :
from Foam.OpenFOAM import readInt
nUCorr = readInt( mesh.solutionDict().subDict( word( "SIMPLE" ) ).lookup( word( "nUCorrectors" ) ) )
pass
if nUCorr > 0 :
pressureImplicitPorosity = True
pass
pass
return p, U, phi, pRefCell, pRefValue, laminarTransport, turbulence, pZones, pressureImplicitPorosity, nUCorr
def createSolidField( solidRegions, runTime ):
#Initialise solid field pointer lists
from Foam.finiteVolume import PtrList_volScalarField, volScalarField
rhos = PtrList_volScalarField( solidRegions.size() )
cps = PtrList_volScalarField( solidRegions.size() )
rhosCps = PtrList_volScalarField( solidRegions.size() )
Ks = PtrList_volScalarField( solidRegions.size() )
Ts = PtrList_volScalarField( solidRegions.size() )
from Foam.OpenFOAM import ext_Info, nl
#Populate solid field pointer lists
from Foam.OpenFOAM import word, IOobject, fileName
for index in range( solidRegions.size() ):
ext_Info()<< "*** Reading solid mesh thermophysical properties for region " \
<< solidRegions[ index ].name() << nl << nl
ext_Info()<< " Adding to rhos\n" << nl
rhos.ext_set( index, volScalarField( IOobject ( word( "rho" ),
fileName( runTime.timeName() ),
solidRegions[ index ],
IOobject.MUST_READ,
IOobject.AUTO_WRITE ),
solidRegions[ index ] ) )
ext_Info()<< " Adding to cps\n" << nl
cps.ext_set( index, volScalarField( IOobject( word( "cp" ),
fileName( runTime.timeName() ),
solidRegions[ index ],
IOobject.MUST_READ,
IOobject.AUTO_WRITE ),
solidRegions[ index ] ) )
rhosCps.ext_set( index, volScalarField( word( "rhosCps" ), rhos[ index ] * cps[ index ] ) )
ext_Info()<< " Adding to Ks\n" << nl
Ks.ext_set( index, volScalarField( IOobject( word( "K" ),
fileName( runTime.timeName() ),
solidRegions[ index ],
IOobject.MUST_READ,
IOobject.AUTO_WRITE ),
solidRegions[ index ] ) )
ext_Info()<< " Adding to Ts\n" << nl
Ts.ext_set( index, volScalarField( IOobject( word( "T" ),
fileName( runTime.timeName() ),
solidRegions[ index ],
IOobject.MUST_READ,
IOobject.AUTO_WRITE ),
solidRegions[ index ] ) )
return rhos, cps, rhosCps, Ks, Ts
def createSolidField(solidRegions, runTime):
#Initialise solid field pointer lists
from Foam.finiteVolume import PtrList_volScalarField, volScalarField
rhos = PtrList_volScalarField(solidRegions.size())
cps = PtrList_volScalarField(solidRegions.size())
rhosCps = PtrList_volScalarField(solidRegions.size())
Ks = PtrList_volScalarField(solidRegions.size())
Ts = PtrList_volScalarField(solidRegions.size())
from Foam.OpenFOAM import ext_Info, nl
#Populate solid field pointer lists
from Foam.OpenFOAM import word, IOobject, fileName
for index in range(solidRegions.size()):
ext_Info()<< "*** Reading solid mesh thermophysical properties for region " \
<< solidRegions[ index ].name() << nl << nl
ext_Info() << " Adding to rhos\n" << nl
rhos.ext_set(
index,
volScalarField(
IOobject(word("rho"), fileName(runTime.timeName()),
solidRegions[index], IOobject.MUST_READ,
IOobject.AUTO_WRITE), solidRegions[index]))
ext_Info() << " Adding to cps\n" << nl
cps.ext_set(
index,
volScalarField(
IOobject(word("cp"), fileName(runTime.timeName()),
solidRegions[index], IOobject.MUST_READ,
IOobject.AUTO_WRITE), solidRegions[index]))
rhosCps.ext_set(
index, volScalarField(word("rhosCps"), rhos[index] * cps[index]))
ext_Info() << " Adding to Ks\n" << nl
Ks.ext_set(
index,
volScalarField(
IOobject(word("K"), fileName(runTime.timeName()),
solidRegions[index], IOobject.MUST_READ,
IOobject.AUTO_WRITE), solidRegions[index]))
ext_Info() << " Adding to Ts\n" << nl
Ts.ext_set(
index,
volScalarField(
IOobject(word("T"), fileName(runTime.timeName()),
solidRegions[index], IOobject.MUST_READ,
IOobject.AUTO_WRITE), solidRegions[index]))
return rhos, cps, rhosCps, Ks, Ts
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 thermophysical properties\n" << nl
ext_Info() << "Reading field T\n" << nl
T = volScalarField( IOobject( word( "T" ),
fileName( runTime.timeName() ),
mesh,
IOobject.MUST_READ,
IOobject.AUTO_WRITE ),
mesh )
ext_Info() << "Reading field p\n" << nl
p = volScalarField( IOobject( word( "p" ),
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 )
laminarTransport, beta, TRef,Pr, Prt = readTransportProperties( U, phi )
ext_Info() << "Creating turbulence model\n" << nl
from Foam import incompressible
turbulence = incompressible.RASModel.New( U, phi, laminarTransport )
pRefCell = 0
pRefValue = 0.0
from Foam.finiteVolume import setRefCell
pRefCell, pRefValue = setRefCell( p, mesh.solutionDict().subDict( word( "PISO" ) ), pRefCell, pRefValue )
# Kinematic density for buoyancy force
rhok = volScalarField( IOobject( word( "rhok" ),
fileName( runTime.timeName() ),
mesh ),
1.0 - beta * ( T - TRef ) )
return T, p, U, phi, laminarTransport, beta, TRef,Pr, Prt, turbulence, pRefCell, pRefValue, rhok
def create_fields(runTime, mesh):
from Foam.OpenFOAM import ext_Info, nl
ext_Info() << "Reading thermophysical properties\n" << nl
from Foam.thermophysicalModels import basicPsiThermo, autoPtr_basicPsiThermo
thermo = basicPsiThermo.New(mesh)
p = thermo.p()
h = thermo.h()
psi = thermo.psi()
from Foam.OpenFOAM import IOobject, word, fileName
from Foam.finiteVolume import volScalarField
rho = volScalarField(
IOobject(word("rho"), fileName(runTime.timeName()), mesh,
IOobject.READ_IF_PRESENT, IOobject.AUTO_WRITE), thermo.rho())
ext_Info() << "Reading field U\n" << nl
from Foam.finiteVolume import volVectorField
U = volVectorField(
IOobject(word("U"), fileName(runTime.timeName()), mesh,
IOobject.MUST_READ, IOobject.AUTO_WRITE), mesh)
from Foam.finiteVolume.cfdTools.compressible import compressibleCreatePhi
phi = compressibleCreatePhi(runTime, mesh, rho, U)
from Foam.OpenFOAM import dimensionedScalar
pMin = dimensionedScalar(mesh.solutionDict().subDict(
word("PIMPLE")).lookup(word("pMin")))
ext_Info() << "Creating turbulence model\n" << nl
from Foam import compressible
turbulence = compressible.turbulenceModel.New(rho, U, phi, thermo())
# initialMass = fvc.domainIntegrate(rho)
ext_Info() << "Creating field DpDt\n" << nl
from Foam import fvc
from Foam.finiteVolume import surfaceScalarField
DpDt = fvc.DDt(
surfaceScalarField(word("phiU"), phi / fvc.interpolate(rho)), p)
from Foam.finiteVolume import MRFZones
mrfZones = MRFZones(mesh)
mrfZones.correctBoundaryVelocity(U)
from Foam.finiteVolume import porousZones
pZones = porousZones(mesh)
from Foam.OpenFOAM import Switch
pressureImplicitPorosity = Switch(False)
return thermo, turbulence, p, h, psi, rho, U, phi, pMin, DpDt, mrfZones, pZones, pressureImplicitPorosity
def create_fields(runTime, mesh):
from Foam.OpenFOAM import ext_Info, nl
ext_Info() << "Reading field p\n" << nl
from Foam.OpenFOAM import IOobject, word, fileName
from Foam.finiteVolume import volScalarField
p = volScalarField(
IOobject(word("p"), 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)
pRefCell = 0
pRefValue = 0.0
from Foam.finiteVolume import setRefCell
pRefCell, pRefValue = setRefCell(
p,
mesh.solutionDict().subDict(word("SIMPLE")), pRefCell, pRefValue)
from Foam.transportModels import singlePhaseTransportModel
laminarTransport = singlePhaseTransportModel(U, phi)
from Foam import incompressible
turbulence = incompressible.RASModel.New(U, phi, laminarTransport)
from Foam.finiteVolume import porousZones
pZones = porousZones(mesh)
from Foam.OpenFOAM import Switch
pressureImplicitPorosity = Switch(False)
nUCorr = 0
if pZones.size():
# nUCorrectors for pressureImplicitPorosity
if (mesh.solutionDict().subDict(word("SIMPLE")).found(
word("nUCorrectors"))):
from Foam.OpenFOAM import readInt
nUCorr = readInt(mesh.solutionDict().subDict(
word("SIMPLE")).lookup(word("nUCorrectors")))
pass
if nUCorr > 0:
pressureImplicitPorosity = True
pass
pass
return p, U, phi, pRefCell, pRefValue, laminarTransport, turbulence, pZones, pressureImplicitPorosity, nUCorr
def createFields(runTime, mesh, g):
ext_Info() << "Reading thermophysical properties\n" << nl
from Foam.thermophysicalModels import autoPtr_basicPsiThermo, basicPsiThermo
thermo = basicPsiThermo.New(mesh)
from Foam.finiteVolume import volScalarField
from Foam.OpenFOAM import IOobject, word, fileName
rho = volScalarField(
IOobject(word("rho"), fileName(runTime.timeName()), mesh,
IOobject.NO_READ, IOobject.NO_WRITE), thermo.rho())
p = thermo.p()
h = thermo.h()
psi = thermo.psi()
ext_Info() << "Reading field U\n" << nl
from Foam.finiteVolume import volVectorField
U = volVectorField(
IOobject(word("U"), fileName(runTime.timeName()), mesh,
IOobject.MUST_READ, IOobject.AUTO_WRITE), mesh)
from Foam.finiteVolume.cfdTools.compressible import compressibleCreatePhi
phi = compressibleCreatePhi(runTime, mesh, rho, U)
ext_Info() << "Creating turbulence model\n" << nl
from Foam import compressible
turbulence = compressible.RASModel.New(rho, U, phi, thermo())
ext_Info() << "Calculating field g.h\n" << nl
gh = volScalarField(word("gh"), g & mesh.C())
from Foam.finiteVolume import surfaceScalarField
ghf = surfaceScalarField(word("ghf"), g & mesh.Cf())
ext_Info() << "Reading field p_rgh\n" << nl
p_rgh = volScalarField(
IOobject(word("p_rgh"), fileName(runTime.timeName()), mesh,
IOobject.MUST_READ, IOobject.AUTO_WRITE), mesh)
#Force p_rgh to be consistent with p
p_rgh.ext_assign(p - rho * gh)
pRefCell = 0
pRefValue = 0.0
from Foam.finiteVolume import setRefCell
pRefCell, pRefValue = setRefCell(
p, p_rgh,
mesh.solutionDict().subDict(word("SIMPLE")), pRefCell, pRefValue)
from Foam import fvc
initialMass = fvc.domainIntegrate(rho)
totalVolume = mesh.V().ext_sum()
return thermo, rho, p, h, psi, U, phi, turbulence, gh, ghf, p_rgh, pRefCell, pRefValue, initialMass, totalVolume
def _createFields( runTime, mesh ):
from Foam.OpenFOAM import ext_Info, nl
ext_Info() << "Reading thermophysical properties\n" << nl
from Foam.thermophysicalModels import basicPsiThermo
thermo = basicPsiThermo.New( mesh )
from Foam.OpenFOAM import IOdictionary, IOobject, word, fileName
from Foam.finiteVolume import volScalarField
rho = volScalarField( IOobject( word( "rho" ),
fileName( runTime.timeName() ),
mesh,
IOobject.READ_IF_PRESENT,
IOobject.AUTO_WRITE ),
thermo.rho() )
p = thermo.p()
h = thermo.h()
psi = thermo.psi()
ext_Info() << "Reading field U\n" << nl
from Foam.finiteVolume import volVectorField
U = volVectorField( IOobject( word( "U" ),
fileName( runTime.timeName() ),
mesh,
IOobject.MUST_READ,
IOobject.AUTO_WRITE ),
mesh )
from Foam.finiteVolume.cfdTools.compressible import compressibleCreatePhi
phi = compressibleCreatePhi( runTime, mesh, rho, U )
pRefCell = 0
pRefValue = 0.0
from Foam.finiteVolume import setRefCell
pRefCell, pRefValue = setRefCell( p, mesh.solutionDict().subDict( word( "SIMPLE" ) ), pRefCell, pRefValue )
from Foam.OpenFOAM import dimensionedScalar
pMin = dimensionedScalar( mesh.solutionDict().subDict( word( "SIMPLE" ) ).lookup( word( "pMin" ) ) )
ext_Info() << "Creating turbulence model\n" << nl
from Foam import compressible
turbulence = compressible.RASModel.New( rho,
U,
phi,
thermo() )
from Foam.OpenFOAM import dimensionedScalar
from Foam import fvc
initialMass = fvc.domainIntegrate( rho )
return thermo, rho, p, h, psi, U, phi, pRefCell, pRefValue, turbulence, initialMass, pMin
def create_fields(runTime, mesh, g):
from Foam.OpenFOAM import ext_Info, nl
ext_Info() << "Reading thermophysical properties\n" << nl
from Foam.thermophysicalModels import basicRhoThermo
thermo = basicRhoThermo.New(mesh)
from Foam.OpenFOAM import IOobject, word, fileName
from Foam.finiteVolume import volScalarField
rho = volScalarField(
IOobject(word("rho"), fileName(runTime.timeName()), mesh,
IOobject.NO_READ, IOobject.NO_WRITE), thermo.rho())
p = thermo.p()
h = thermo.h()
psi = thermo.psi()
ext_Info() << "Reading field U\n" << nl
from Foam.finiteVolume import volVectorField
U = volVectorField(
IOobject(word("U"), fileName(runTime.timeName()), mesh,
IOobject.MUST_READ, IOobject.AUTO_WRITE), mesh)
from Foam.finiteVolume.cfdTools.compressible import compressibleCreatePhi
phi = compressibleCreatePhi(runTime, mesh, rho, U)
ext_Info() << "Creating turbulence model\n" << nl
from Foam import compressible
turbulence = compressible.turbulenceModel.New(rho, U, phi, thermo())
ext_Info() << "Calculating field g.h\n" << nl
gh = volScalarField(word("gh"), g & mesh.C())
from Foam.finiteVolume import surfaceScalarField
ghf = surfaceScalarField(word("ghf"), g & mesh.Cf())
ext_Info() << "Reading field p_rgh\n" << nl
p_rgh = volScalarField(
IOobject(word("p_rgh"), fileName(runTime.timeName()), mesh,
IOobject.MUST_READ, IOobject.AUTO_WRITE), mesh)
# Force p_rgh to be consistent with p
p_rgh.ext_assign(p - rho * gh)
ext_Info() << "Creating field DpDt\n" << nl
from Foam import fvc
DpDt = volScalarField(
word("DpDt"),
fvc.DDt(surfaceScalarField(word("phiU"), phi / fvc.interpolate(rho)),
p))
return thermo, p, rho, h, psi, U, phi, turbulence, gh, ghf, p_rgh, DpDt
def alphaEqns( runTime, mesh, rho1, rho2, rhoPhi, phic, dgdt, divU, alpha1, alpha2, phi, interface, nAlphaCorr ):
from Foam.OpenFOAM import word
alphaScheme = word( "div(phi,alpha)" )
alpharScheme = word( "div(phirb,alpha)" )
phir = phic*interface.nHatf()
from Foam.finiteVolume import volScalarField
from Foam.OpenFOAM import IOobject, word, fileName, dimensionedScalar, scalar, ext_Info, nl
for gCorr in range( nAlphaCorr ):
Sp = volScalarField.DimensionedInternalField( IOobject( word( "Sp" ),
fileName( runTime.timeName() ),
mesh ),
mesh,
dimensionedScalar( word( "Sp" ), dgdt.dimensions(), 0.0 ) )
Su = volScalarField.DimensionedInternalField( IOobject( word( "Su" ),
fileName( runTime.timeName() ),
mesh ),
# Divergence term is handled explicitly to be
# consistent with the explicit transport solution
divU * alpha1.ext_min( scalar( 1 ) ) )
for celli in range( dgdt.size() ):
if dgdt[ celli ] > 0.0 and alpha1[ celli ] > 0.0:
Sp[ celli ] -= dgdt[ celli ] * alpha1[ celli ]
Su[ celli ] += dgdt[ celli ] * alpha1[ celli ]
pass
elif dgdt[ celli ] < 0.0 and alpha1[ celli ] < 1.0:
Sp[ celli ] += dgdt[ celli ] * ( 1.0 - alpha1[ celli ] )
pass
pass
from Foam import fvc
phiAlpha1 = fvc.flux( phi, alpha1, alphaScheme ) + fvc.flux( - fvc.flux( -phir, alpha2, alpharScheme ), alpha1, alpharScheme )
from Foam import MULES
from Foam.OpenFOAM import geometricOneField
MULES.explicitSolve( geometricOneField(), alpha1, phi, phiAlpha1, Sp, Su, 1.0, 0.0 )
rho1f = fvc.interpolate( rho1 )
rho2f = fvc.interpolate( rho2 )
rhoPhi.ext_assign( phiAlpha1 * ( rho1f - rho2f ) + phi * rho2f )
alpha2.ext_assign( scalar( 1 ) - alpha1 )
pass
from Foam.OpenFOAM import ext_Info, nl
ext_Info() << "Liquid phase volume fraction = " << alpha1.weightedAverage( mesh.V() ).value() \
<< " Min(alpha1) = " << alpha1.ext_min().value() << " Min(alpha2) = " << alpha2.ext_min().value() << nl
pass
def createTime( rootPath, caseName ) :
print "Create time for '%s'\n" % caseName
from Foam.OpenFOAM import Time
from Foam.OpenFOAM import fileName
runTime = Time( Time.controlDictName.fget(),
fileName( rootPath ),
fileName( caseName ) )
#runTime.setTime( runTime.endTime(), 0 )
return runTime
def writeGradP( runTime, gradP ):
if runTime.outputTime():
from Foam.OpenFOAM import OFstream, fileName
gradPFile = OFstream( runTime.path()/fileName( runTime.timeName() )/fileName( "uniform" )/fileName( "gradP.raw" ) )
from Foam.OpenFOAM import nl, ext_Info
if gradPFile.good():
gradPFile << gradP << nl
pass
else:
ext_Info() << "Cannot open file " << runTime.path()/fileName( runTime.timeName() )/fileName( "uniform" )/fileName( "gradP.raw" )
import os
os.abort()
def _createFields( runTime, mesh, g ):
from Foam.OpenFOAM import ext_Info, nl
ext_Info() << "Reading thermophysical properties\n" << nl
from Foam.thermophysicalModels import basicRhoThermo
thermo = basicRhoThermo.New( mesh )
from Foam.OpenFOAM import IOdictionary, IOobject, word, fileName
from Foam.finiteVolume import volScalarField
rho= volScalarField( IOobject( word( "rho" ),
fileName( runTime.timeName() ),
mesh,
IOobject.NO_READ,
IOobject.NO_WRITE ),
thermo.rho() )
p = thermo.p()
h = thermo.h()
psi = thermo.psi()
ext_Info() << "Reading field U\n" << nl
from Foam.finiteVolume import volVectorField
U = volVectorField( IOobject( word( "U" ),
fileName( runTime.timeName() ),
mesh,
IOobject.MUST_READ,
IOobject.AUTO_WRITE ),
mesh )
from Foam.finiteVolume.cfdTools.compressible import compressibleCreatePhi
phi = compressibleCreatePhi( runTime, mesh, rho, U )
ext_Info() << "Creating turbulence model\n" << nl
from Foam import compressible
turbulence = compressible.turbulenceModel.New( rho, U, phi, thermo() )
ext_Info() << "Creating field DpDt\n" << nl
from Foam import fvc
from Foam.finiteVolume import surfaceScalarField
DpDt = volScalarField( word( "DpDt" ),
fvc.DDt( surfaceScalarField( word( "phiU" ), phi / fvc.interpolate( rho ) ), p ) )
thermo.correct()
initialMass = fvc.domainIntegrate(rho);
totalVolume = mesh.V().ext_sum()
return thermo, p, h, psi, phi, rho, U, turbulence, DpDt, initialMass, totalVolume
def _createFields( runTime, mesh ):
from Foam.OpenFOAM import ext_Info, nl
ext_Info() << "Reading thermophysical properties\n" << nl
from Foam.thermophysicalModels import basicPsiThermo
thermo = basicPsiThermo.New( mesh )
from Foam.OpenFOAM import IOdictionary, IOobject, word, fileName
from Foam.finiteVolume import volScalarField
rho = volScalarField( IOobject( word( "rho" ),
fileName( runTime.timeName() ),
mesh,
IOobject.NO_READ,
IOobject.NO_WRITE ),
thermo.rho() )
p = thermo.p()
h = thermo.h()
psi = thermo.psi()
ext_Info() << "Reading field U\n" << nl
from Foam.finiteVolume import volVectorField
U = volVectorField( IOobject( word( "U" ),
fileName( runTime.timeName() ),
mesh,
IOobject.MUST_READ,
IOobject.AUTO_WRITE ),
mesh )
from Foam.finiteVolume.cfdTools.compressible import compressibleCreatePhi
phi = compressibleCreatePhi( runTime, mesh, rho, U )
ext_Info() << "Creating turbulence model\n" << nl
from Foam import compressible
turbulence = compressible.RASModel.New( rho, U, phi, thermo() )
thermo.correct()
pRefCell = 0
pRefValue = 0.0
from Foam.finiteVolume import setRefCell
pRefCell, pRefValue = setRefCell( p, mesh.solutionDict().subDict( word( "SIMPLE" ) ), pRefCell, pRefValue )
from Foam import fvc
initialMass = fvc.domainIntegrate(rho)
return thermo, rho, p, h, psi, U, phi, turbulence, initialMass, pRefCell, pRefValue
def _createFields( runTime, mesh ):
from Foam.OpenFOAM import ext_Info, nl
from Foam.OpenFOAM import IOdictionary, IOobject, word, fileName
from Foam.finiteVolume import volScalarField
ext_Info() << "Reading field p\n" << nl
p = volScalarField( IOobject( word( "p" ),
fileName( runTime.timeName() ),
mesh(),
IOobject.MUST_READ,
IOobject.AUTO_WRITE ),
mesh() )
from Foam.finiteVolume import volVectorField
ext_Info() << "Reading field U\n" << nl
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 )
pRefCell = 0
pRefValue = 0.0
from Foam.finiteVolume import setRefCell
pRefCell, pRefValue = setRefCell( p, mesh.solutionDict().subDict( word( "PIMPLE" ) ), pRefCell, pRefValue )
from Foam.transportModels import singlePhaseTransportModel
laminarTransport = singlePhaseTransportModel( U, phi )
from Foam import incompressible
turbulence = incompressible.turbulenceModel.New( U, phi, laminarTransport )
from Foam.finiteVolume import zeroGradientFvPatchScalarField
ext_Info() << "Reading field rAU if present\n" << nl
rAU = volScalarField( IOobject( word( "rAU" ),
fileName( runTime.timeName() ),
mesh(),
IOobject.READ_IF_PRESENT,
IOobject.AUTO_WRITE ),
mesh(),
runTime.deltaT(),
zeroGradientFvPatchScalarField.typeName )
return p, U, phi, laminarTransport, turbulence, rAU, pRefCell, pRefValue
def _createFields(runTime, mesh):
from Foam.OpenFOAM import ext_Info, nl
ext_Info() << "Reading thermophysical properties\n" << nl
from Foam.thermophysicalModels import basicPsiThermo, autoPtr_basicPsiThermo
thermo = basicPsiThermo.New(mesh)
p = thermo.p()
h = thermo.h()
psi = thermo.psi()
from Foam.OpenFOAM import IOdictionary, IOobject, word, fileName
from Foam.finiteVolume import volScalarField
rho = volScalarField(
IOobject(word("rho"), fileName(runTime.timeName()), mesh, IOobject.READ_IF_PRESENT, IOobject.AUTO_WRITE),
thermo.rho(),
)
ext_Info() << "Reading field U\n" << nl
from Foam.finiteVolume import volVectorField
U = volVectorField(
IOobject(word("U"), fileName(runTime.timeName()), mesh, IOobject.MUST_READ, IOobject.AUTO_WRITE), mesh
)
from Foam.finiteVolume.cfdTools.compressible import compressibleCreatePhi
phi = compressibleCreatePhi(runTime, mesh, rho, U)
from Foam.OpenFOAM import dimensionedScalar
pMin = dimensionedScalar(mesh.solutionDict().subDict(word("PIMPLE")).lookup(word("pMin")))
ext_Info() << "Creating turbulence model\n" << nl
from Foam import compressible
turbulence = compressible.turbulenceModel.New(rho, U, phi, thermo())
ext_Info() << "Creating field DpDt\n" << nl
from Foam import fvc
from Foam.finiteVolume import surfaceScalarField
DpDt = fvc.DDt(surfaceScalarField(word("phiU"), phi / fvc.interpolate(rho)), p)
return p, h, psi, rho, U, phi, turbulence, thermo, pMin, DpDt
def rho(self, *args):
if len(args) > 1:
raise AttributeError("len(args) > 1")
if len(args) == 1:
try:
arg = float(args[0])
except ValueError:
raise AttributeError("The arg is not float")
from Foam.finiteVolume import volScalarField, zeroGradientFvPatchScalarField
from Foam.OpenFOAM import word, fileName, IOobject, dimensionedScalar, dimDensity
result = volScalarField(
IOobject(word("rho"), fileName(self.mesh().time().timeName()),
self.mesh(), IOobject.NO_READ, IOobject.NO_WRITE),
self.mesh(), dimensionedScalar(word("zeroRho"), dimDensity, 0.0),
zeroGradientFvPatchScalarField.typeName)
#Accumulate data for all fields
from Foam.OpenFOAM import ext_Info
for lawI in self:
# Python does not wait for evaluation of the closure expression, it destroys return values if it is no more in use
lawI_rho = lawI.rho()
result.internalField().ext_assign(
result.internalField() +
self.indicator(self.index(lawI)) * lawI_rho.internalField())
result.correctBoundaryConditions()
return result
def mu( self, *args ):
if len(args) > 1:
raise AttributeError("len(args) > 1")
flag = False
if len(args) == 1:
try:
t = float(args[0])
flag = True
except ValueError:
raise AttributeError ("The arg is not float")
if flag:
lawE = self.lawPtr_.E( t )
lawNu = self.lawPtr_.nu( t )
else:
lawE = self.lawPtr_.E()
lawNu = self.lawPtr_.nu()
from Foam.finiteVolume import volScalarField
from Foam.OpenFOAM import word, fileName, IOobject
result = volScalarField( IOobject( word( "mu" ),
fileName( self.sigma_.time().timeName() ),
self.sigma_.db(),
IOobject.NO_READ,
IOobject.NO_WRITE ),
lawE / ( 2.0 * ( 1.0 + lawNu ) ) )
return result
def readThermodynamicProperties( runTime, mesh ):
from Foam.OpenFOAM import ext_Info, nl
ext_Info() << "Reading thermodynamicProperties\n" << nl
from Foam.OpenFOAM import IOdictionary, IOobject, word, fileName
thermodynamicProperties = IOdictionary( IOobject( word( "thermodynamicProperties" ),
fileName( runTime.constant() ),
mesh,
IOobject.MUST_READ,
IOobject.NO_WRITE ) )
from Foam.OpenFOAM import dimensionedScalar
R = dimensionedScalar( thermodynamicProperties.lookup( word( "R" ) ) )
Cv = dimensionedScalar( thermodynamicProperties.lookup( word( "Cv" ) ) )
Cp = Cv + R
gamma = Cp / Cv
from Foam.OpenFOAM import dimless
Pr = dimensionedScalar( word( "Pr" ), dimless, 1.0 )
if thermodynamicProperties.found( word( "Pr" ) ) :
Pr = dimensionedScalar( thermodynamicProperties.lookup( "Pr" ) )
pass
return thermodynamicProperties, R, Cv, Cp, gamma, Pr
def readThermodynamicProperties(runTime, mesh):
from Foam.OpenFOAM import ext_Info, nl
ext_Info() << "Reading thermodynamicProperties\n" << nl
from Foam.OpenFOAM import IOdictionary, IOobject, word, fileName
thermodynamicProperties = IOdictionary(
IOobject(
word("thermodynamicProperties"), fileName(runTime.constant()), mesh, IOobject.MUST_READ, IOobject.NO_WRITE
)
)
from Foam.OpenFOAM import dimensionedScalar
rho0 = dimensionedScalar(thermodynamicProperties.lookup(word("rho0")))
p0 = dimensionedScalar(thermodynamicProperties.lookup(word("p0")))
psi = dimensionedScalar(thermodynamicProperties.lookup(word("psi")))
# Density offset, i.e. the constant part of the density
rhoO = dimensionedScalar(word("rhoO"), rho0 - psi * p0)
return thermodynamicProperties, rho0, p0, psi, rhoO
def nu( self, *args):
if len(args) > 1:
raise AttributeError("len(args) > 1")
if len(args) == 1:
try:
arg = float(args[0])
except ValueError:
raise AttributeError ("The arg is not float")
from Foam.finiteVolume import volScalarField, zeroGradientFvPatchScalarField
from Foam.OpenFOAM import word, fileName, IOobject, dimensionedScalar, dimless
result = volScalarField( IOobject( word( "nu" ),
fileName( self.mesh().time().timeName() ),
self.mesh(),
IOobject.NO_READ,
IOobject.NO_WRITE ),
self.mesh(),
dimensionedScalar( word( "zeroE" ), dimless, 0.0 ),
zeroGradientFvPatchScalarField.typeName )
#Accumulate data for all fields
for lawI in self:
# Python does not wait for evaluation of the closure expression, it destroys return values if it is no more in use
lawI_nu =lawI.nu()
result.internalField().ext_assign( result.internalField() + \
self.indicator( self.index( lawI ) ) * lawI_nu.internalField() )
result.correctBoundaryConditions()
return result
def readThermodynamicProperties(runTime, mesh):
from Foam.OpenFOAM import ext_Info, nl
ext_Info() << "Reading thermodynamicProperties\n" << nl
from Foam.OpenFOAM import IOdictionary, IOobject, word, fileName
thermodynamicProperties = IOdictionary(
IOobject(word("thermodynamicProperties"), fileName(runTime.constant()),
mesh, IOobject.MUST_READ, IOobject.NO_WRITE))
from Foam.OpenFOAM import dimensionedScalar
R = dimensionedScalar(thermodynamicProperties.lookup(word("R")))
Cv = dimensionedScalar(thermodynamicProperties.lookup(word("Cv")))
Cp = Cv + R
gamma = Cp / Cv
from Foam.OpenFOAM import dimless
Pr = dimensionedScalar(word("Pr"), dimless, 1.0)
if thermodynamicProperties.found(word("Pr")):
Pr = dimensionedScalar(thermodynamicProperties.lookup("Pr"))
pass
return thermodynamicProperties, R, Cv, Cp, gamma, Pr
def _createFields(runTime, mesh, g):
from Foam.OpenFOAM import ext_Info, nl
ext_Info() << "Reading thermophysical properties\n" << nl
from Foam.thermophysicalModels import basicRhoThermo
thermo = basicRhoThermo.New(mesh)
from Foam.OpenFOAM import IOdictionary, IOobject, word, fileName
from Foam.finiteVolume import volScalarField
rho = volScalarField(
IOobject(word("rho"), fileName(runTime.timeName()), mesh,
IOobject.NO_READ, IOobject.NO_WRITE), thermo.rho())
p = thermo.p()
h = thermo.h()
psi = thermo.psi()
ext_Info() << "Reading field U\n" << nl
from Foam.finiteVolume import volVectorField
U = volVectorField(
IOobject(word("U"), fileName(runTime.timeName()), mesh,
IOobject.MUST_READ, IOobject.AUTO_WRITE), mesh)
from Foam.finiteVolume.cfdTools.compressible import compressibleCreatePhi
phi = compressibleCreatePhi(runTime, mesh, rho, U)
ext_Info() << "Creating turbulence model\n" << nl
from Foam import compressible
turbulence = compressible.turbulenceModel.New(rho, U, phi, thermo())
ext_Info() << "Creating field DpDt\n" << nl
from Foam import fvc
from Foam.finiteVolume import surfaceScalarField
DpDt = volScalarField(
word("DpDt"),
fvc.DDt(surfaceScalarField(word("phiU"), phi / fvc.interpolate(rho)),
p))
thermo.correct()
initialMass = fvc.domainIntegrate(rho)
totalVolume = mesh.V().ext_sum()
return thermo, p, h, psi, phi, rho, U, turbulence, DpDt, initialMass, totalVolume
def createGradP( runTime ):
from Foam.OpenFOAM import dimensionedScalar, dimensionSet, IFstream, word
gradP = dimensionedScalar( word( "gradP" ),
dimensionSet( 0.0, 1.0, -2.0, 0.0, 0.0 ),
0.0 )
from Foam.OpenFOAM import word, fileName, ext_Info, nl
gradPFile = IFstream( runTime.path()/fileName( runTime.timeName() )/fileName( "uniform" )/ fileName( "gradP.raw" ) )
if gradPFile.good():
gradPFile >> gradP
ext_Info() << "Reading average pressure gradient" << nl << nl
pass
else:
ext_Info() << "Initializing with 0 pressure gradient" << nl << nl
pass
return gradP, gradPFile
def _createFields( runTime, mesh, R, Cv ):
from Foam.OpenFOAM import ext_Info, nl
ext_Info() << "Reading field p\n" << nl
from Foam.OpenFOAM import IOdictionary, IOobject, word, fileName
from Foam.finiteVolume import volScalarField
p = volScalarField( IOobject( word( "p" ),
fileName( runTime.timeName() ),
mesh,
IOobject.MUST_READ,
IOobject.AUTO_WRITE ),
mesh )
ext_Info() << "Reading field T\n" << nl
T = volScalarField( IOobject( word( "T" ),
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 )
psi = volScalarField( IOobject( word( "psi" ),
fileName( runTime.timeName() ),
mesh,
IOobject.NO_READ,
IOobject.NO_WRITE ),
1.0 / ( R * T ) )
psi.oldTime()
rho = volScalarField( IOobject( word( "rho" ),
fileName( runTime.timeName() ),
mesh ),
psi * p,
p.ext_boundaryField().types() )
rhoU = volVectorField( IOobject( word( "rhoU" ),
fileName( runTime.timeName() ) ,
mesh,
IOobject.NO_READ,
IOobject.NO_WRITE ),
rho * U,
U.ext_boundaryField().types() )
rhoE = volScalarField( IOobject( word( "rhoE" ),
fileName( runTime.timeName() ),
mesh,
IOobject.NO_READ,
IOobject.NO_WRITE ),
rho * Cv * T + 0.5 * rho * ( rhoU / rho ).magSqr(),
T.ext_boundaryField().types() )
return p, T, U, psi, rho, rhoU, rhoE
def createFields( runTime, mesh ):
from Foam.OpenFOAM import ext_Info, nl
ext_Info() << "Reading thermophysical properties\n" << nl
from Foam.thermophysicalModels import basicThermo, autoPtr_basicThermo
thermo = basicThermo.New( mesh )
p = thermo.p()
h = thermo.h()
psi = thermo.psi()
rho = thermo.rho()
from Foam.OpenFOAM import IOdictionary, IOobject, word, fileName
from Foam.finiteVolume import volScalarField
rho = volScalarField( IOobject( word( "rho" ),
fileName( runTime.timeName() ),
mesh ),
rho )
ext_Info() << "Reading field U\n" << nl
from Foam.finiteVolume import volVectorField
U = volVectorField( IOobject( word( "U" ),
fileName( runTime.timeName() ),
mesh,
IOobject.MUST_READ,
IOobject.AUTO_WRITE ),
mesh )
from Foam.finiteVolume.cfdTools.compressible import compressibleCreatePhi
phi = compressibleCreatePhi( runTime, mesh, rho, U )
ext_Info() << "Creating turbulence model\n" << nl
from Foam import compressible
turbulence = compressible.RASModel.New( rho,
U,
phi,
thermo() )
ext_Info() << "Creating field DpDt\n" << nl
from Foam import fvc
from Foam.finiteVolume import surfaceScalarField
DpDt = fvc.DDt( surfaceScalarField(word( "phiU" ), phi / fvc.interpolate( rho ) ), p );
return thermo, p, h, psi, rho, U, phi, turbulence, DpDt
def readGravitationalAcceleration(runTime, mesh):
ext_Info() << "\nReading g" << nl
from Foam.OpenFOAM import uniformDimensionedVectorField
from Foam.OpenFOAM import word, IOobject, fileName
g = uniformDimensionedVectorField(
IOobject(word("g"), fileName(runTime.constant()), mesh,
IOobject.MUST_READ, IOobject.NO_WRITE))
return g
def calculateStress( runTime, mesh, sigma, _lambda ):
if (runTime.outputTime()):
from Foam.finiteVolume import volScalarField
from Foam.OpenFOAM import word, IOobject, fileName
sigmaEq = volScalarField( IOobject( word( "sigmaEq" ),
fileName( runTime.timeName() ),
mesh,
IOobject.NO_READ,
IOobject.AUTO_WRITE ),
( (3.0/2.0)*sigma.dev() .magSqr() ).sqrt() )
ext_Info() << "Max sigmaEq = " << sigmaEq.ext_max().value() << nl
from Foam.OpenFOAM import symmTensor
sigmaxx = volScalarField( IOobject( word( "sigmaxx" ),
fileName( runTime.timeName() ),
mesh,
IOobject.NO_READ,
IOobject.AUTO_WRITE ),
sigma.component(symmTensor.XX) )
sigmayy = volScalarField( IOobject( word( "sigmayy" ),
fileName( runTime.timeName() ),
mesh,
IOobject.NO_READ,
IOobject.AUTO_WRITE ),
sigma.component(symmTensor.YY) )
sigmazz = volScalarField( IOobject( word( "sigmazz" ),
fileName( runTime.timeName() ),
mesh,
IOobject.NO_READ,
IOobject.AUTO_WRITE ),
sigma.component(symmTensor.ZZ) )
ext_Info() << "Max sigmazz = " << sigmazz.ext_max().value() << nl
sigmaxy = volScalarField( IOobject( word( "sigmaxy" ),
fileName( runTime.timeName() ),
mesh,
IOobject.NO_READ,
IOobject.AUTO_WRITE ),
sigma.component(symmTensor.XY) )
sigmaxz = volScalarField( IOobject( word( "sigmaxz" ),
fileName( runTime.timeName() ),
mesh,
IOobject.NO_READ,
IOobject.AUTO_WRITE ),
sigma.component(symmTensor.XZ) )
sigmayz = volScalarField( IOobject( word( "sigmayz" ),
fileName( runTime.timeName() ),
mesh,
IOobject.NO_READ,
IOobject.AUTO_WRITE ),
sigma.component(symmTensor.YZ) )
runTime.write()
pass
def _createFields( runTime, mesh ):
from Foam.OpenFOAM import ext_Info, nl
from Foam.OpenFOAM import IOdictionary, IOobject, word, fileName
from Foam.finiteVolume import volScalarField
ext_Info() << "Reading field p\n" << nl
p = volScalarField( IOobject( word( "p" ),
fileName( runTime.timeName() ),
mesh,
IOobject.MUST_READ,
IOobject.NO_WRITE ),
mesh )
from Foam.OpenFOAM import dimensionedScalar
p.ext_assign( dimensionedScalar( word( "zero" ), p.dimensions(), 0.0 ) )
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.OpenFOAM import dimensionedVector, vector
U.ext_assign( dimensionedVector( word( "0" ), U.dimensions(), vector.zero ) )
from Foam.finiteVolume import surfaceScalarField
from Foam import fvc
phi = surfaceScalarField( IOobject( word( "phi" ),
fileName( runTime.timeName() ),
mesh,
IOobject.NO_READ,
IOobject.AUTO_WRITE ),
fvc.interpolate( U ) & mesh.Sf() )
pRefCell = 0
pRefValue = 0.0
from Foam.finiteVolume import setRefCell
pRefCell, pRefValue = setRefCell( p, mesh.solutionDict().subDict( word( "SIMPLE" ) ), pRefCell, pRefValue )
return p, U, phi, pRefCell, pRefValue
def __init__( self, runTime ):
from Foam.OpenFOAM import IOobject, word, fileName
IOdictionary.__init__( self, IOobject( word( "regionProperties" ),
fileName( runTime.time().constant() ),
runTime.db(),
IOobject.MUST_READ,
IOobject.NO_WRITE ) )
from Foam.OpenFOAM import wordList
self.fluidRegionNames = wordList( self.lookup( word( "fluidRegionNames" ) ) )
self.solidRegionNames = wordList( self.lookup( word( "solidRegionNames" ) ) )
pass
def createDynamicFvMesh_010600(runTime):
from Foam.OpenFOAM import ext_Info, nl, IOobject, fileName
ext_Info() << "Create mesh for time = " << runTime.timeName() << nl << nl
from Foam.dynamicFvMesh import dynamicFvMesh
mesh = dynamicFvMesh.New(
IOobject(dynamicFvMesh.defaultRegion, fileName(runTime.timeName()),
runTime))
return mesh
def __init__(self, runTime):
from Foam.OpenFOAM import IOobject, word, fileName
IOdictionary.__init__(
self,
IOobject(word("regionProperties"),
fileName(runTime.time().constant()), runTime.db(),
IOobject.MUST_READ, IOobject.NO_WRITE))
from Foam.OpenFOAM import wordList
self.fluidRegionNames = wordList(self.lookup(word("fluidRegionNames")))
self.solidRegionNames = wordList(self.lookup(word("solidRegionNames")))
pass
def readGravitationalAcceleration( runTime, mesh):
from Foam.OpenFOAM import ext_Info, nl
ext_Info() << "\nReading g" << nl
from Foam.OpenFOAM import uniformDimensionedVectorField, IOobject, fileName, word
g = uniformDimensionedVectorField( IOobject( word( "g" ),
fileName( runTime.constant() ),
mesh,
IOobject.MUST_READ,
IOobject.NO_WRITE ) )
return g
def createDynamicFvMesh_010600( runTime ):
from Foam.OpenFOAM import ext_Info, nl, IOobject, fileName
ext_Info() << "Create mesh for time = " << runTime.timeName() << nl << nl
from Foam.dynamicFvMesh import dynamicFvMesh
mesh = dynamicFvMesh.New( IOobject( dynamicFvMesh.defaultRegion,
fileName( runTime.timeName() ),
runTime ) )
return mesh
def _createFields(runTime, mesh):
from Foam.OpenFOAM import ext_Info, nl
from Foam.OpenFOAM import IOdictionary, IOobject, word, fileName
from Foam.finiteVolume import volScalarField
ext_Info() << "Reading field p\n" << nl
p = volScalarField(
IOobject(word("p"), 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)
return p, U, phi
def _createFields(runTime, mesh):
from Foam.OpenFOAM import ext_Info, nl
ext_Info() << "Reading thermophysical properties\n" << nl
from Foam.thermophysicalModels import basicPsiThermo, autoPtr_basicPsiThermo
thermo = basicPsiThermo.New(mesh)
p = thermo.p()
h = thermo.h()
psi = thermo.psi()
from Foam.OpenFOAM import IOdictionary, IOobject, word, fileName
from Foam.finiteVolume import volScalarField
rho = volScalarField(
IOobject(word("rho"), fileName(runTime.timeName()), mesh,
IOobject.READ_IF_PRESENT, IOobject.AUTO_WRITE), thermo.rho())
ext_Info() << "Reading field U\n" << nl
from Foam.finiteVolume import volVectorField
U = volVectorField(
IOobject(word("U"), fileName(runTime.timeName()), mesh,
IOobject.MUST_READ, IOobject.AUTO_WRITE), mesh)
from Foam.finiteVolume.cfdTools.compressible import compressibleCreatePhi
phi = compressibleCreatePhi(runTime, mesh, rho, U)
from Foam.OpenFOAM import dimensionedScalar
pMin = dimensionedScalar(mesh.solutionDict().subDict(
word("PIMPLE")).lookup(word("pMin")))
ext_Info() << "Creating turbulence model\n" << nl
from Foam import compressible
turbulence = compressible.turbulenceModel.New(rho, U, phi, thermo())
ext_Info() << "Creating field DpDt\n" << nl
from Foam import fvc
from Foam.finiteVolume import surfaceScalarField
DpDt = fvc.DDt(
surfaceScalarField(word("phiU"), phi / fvc.interpolate(rho)), p)
return p, h, psi, rho, U, phi, turbulence, thermo, pMin, DpDt
def _createFields(runTime, mesh):
from Foam.OpenFOAM import ext_Info, nl
from Foam.OpenFOAM import IOdictionary, IOobject, word, fileName
from Foam.finiteVolume import volScalarField
ext_Info() << "Reading field p\n" << nl
p = volScalarField(
IOobject(word("p"), fileName(runTime.timeName()), mesh(),
IOobject.MUST_READ, IOobject.AUTO_WRITE), mesh())
from Foam.finiteVolume import volVectorField
ext_Info() << "Reading field U\n" << nl
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)
pRefCell = 0
pRefValue = 0.0
from Foam.finiteVolume import setRefCell
pRefCell, pRefValue = setRefCell(
p,
mesh.solutionDict().subDict(word("PIMPLE")), pRefCell, pRefValue)
from Foam.transportModels import singlePhaseTransportModel
laminarTransport = singlePhaseTransportModel(U, phi)
from Foam import incompressible
turbulence = incompressible.turbulenceModel.New(U, phi, laminarTransport)
from Foam.finiteVolume import zeroGradientFvPatchScalarField
ext_Info() << "Reading field rAU if present\n" << nl
rAU = volScalarField(
IOobject(word("rAU"), fileName(runTime.timeName()), mesh(),
IOobject.READ_IF_PRESENT, IOobject.AUTO_WRITE), mesh(),
runTime.deltaT(), zeroGradientFvPatchScalarField.typeName)
return p, U, phi, laminarTransport, turbulence, rAU, pRefCell, pRefValue
def readTransportProperties(runTime, mesh):
from Foam.OpenFOAM import ext_Info, nl
ext_Info() << "Reading transportProperties\n" << nl
from Foam.OpenFOAM import IOdictionary, IOobject, word, fileName
transportProperties = IOdictionary(
IOobject(word("transportProperties"), fileName(runTime.constant()),
mesh, IOobject.MUST_READ, IOobject.NO_WRITE))
from Foam.OpenFOAM import dimensionedScalar
mu = dimensionedScalar(transportProperties.lookup(word("mu")))
return transportProperties, mu
def sigmaY(self):
from Foam.finiteVolume import volScalarField, zeroGradientFvPatchScalarField
from Foam.OpenFOAM import word, fileName, IOobject, dimensionedScalar, dimForce, dimArea, GREAT
tresult = volScalarField(
IOobject(word("sigmaY"), fileName(self.mesh().time().timeName()),
self.mesh(), IOobject.NO_READ, IOobject.NO_WRITE),
self.mesh(),
dimensionedScalar(word("zeroSigmaY"), dimForce / dimArea, GREAT),
zeroGradientFvPatchScalarField.typeName)
tresult().correctBoundaryConditions()
return tresult
