def readFluidMultiRegionPISOControls( mesh ) :
from Foam.OpenFOAM import word, readInt, Switch
piso = mesh.solutionDict().subDict( word( "PISO" ) )
nCorr = readInt( piso.lookup( word( "nCorrectors" ) ) )
nNonOrthCorr = 0
if piso.found( word( "nNonOrthogonalCorrectors" ) ):
nNonOrthCorr = readInt( piso.lookup( word( "nNonOrthogonalCorrectors" ) ) )
pass
momentumPredictor = True
if piso.found( word( "momentumPredictor" ) ):
momentumPredictor = Switch( piso.lookup( word( "momentumPredictor" ) ) )
pass
transonic = False
if piso.found( word( "transonic" ) ):
transonic = Switch(piso.lookup( word( "transonic" ) ) )
pass
nOuterCorr = 1
if piso.found( word( "nOuterCorrectors" ) ):
nOuterCorr = readInt(piso.lookup( word( "nOuterCorrectors" ) ) )
return piso, nCorr, nNonOrthCorr, momentumPredictor, transonic, nOuterCorr
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 updateCoeffs( self ) :
try:
if self.updated() :
return
from Foam.finiteVolume import volScalarField
from Foam.OpenFOAM import word
rhop = volScalarField.ext_lookupPatchField( self.patch(), word( "rho" ) )
from Foam.finiteVolume import volVectorField
rhoUp =volVectorField.ext_lookupPatchField( self.patch(), word( "rhoU" ) )
T = volScalarField.ext_lookupObject( self.db(), word( "T" ) )
patchi = self.patch().index()
Tp = T.ext_boundaryField()[patchi]
Tp.evaluate()
from Foam.OpenFOAM import IOdictionary
thermodynamicProperties = IOdictionary.ext_lookupObject( self.db(), word( "thermodynamicProperties" ) )
from Foam.OpenFOAM import dimensionedScalar
Cv = dimensionedScalar( thermodynamicProperties.lookup( word( "Cv" ) ) )
self.valueFraction().ext_assign( rhop.ext_snGrad() / ( rhop.ext_snGrad() - rhop * self.patch().deltaCoeffs() ) )
self.refValue().ext_assign( 0.5 * rhop * ( rhoUp / rhop ).magSqr() )
self.refGrad().ext_assign( rhop * Cv.value() * Tp.ext_snGrad() +\
( self.refValue() - ( 0.5 * rhop.patchInternalField()\
* ( rhoUp.patchInternalField() /rhop.patchInternalField() ).magSqr() ) ) * self.patch().deltaCoeffs() )
mixedFvPatchScalarField.updateCoeffs( self )
pass
except Exception, exc:
import sys, traceback
traceback.print_exc( file = sys.stdout )
raise exc
def __init__( self, name, sigma, dict_ ):
from Foam.OpenFOAM import word, dictionary
from Foam.finiteVolume import volSymmTensorField
try:
name = word( str( name ) )
except ValueError:
raise AttributeError("The second arg is not string")
try:
volSymmTensorField.ext_isinstance( sigma )
except TypeError:
raise AssertionError( "sigma != volSymmTensorField" )
from Foam.OpenFOAM import dictionary
try:
dictionary.ext_isinstance( dict_ )
except TypeError:
raise AssertionError( "dict_ != dictionary" )
rheologyLaw.__init__( self, name, sigma, dict_ )
from Foam.OpenFOAM import dimensionedScalar
self.rho_ = dimensionedScalar( dict_.lookup(word( "rho" ) ) )
self.E_ = dimensionedScalar( dict_.lookup( word( "E" ) ) )
self.nu_ = dimensionedScalar( dict_.lookup( word( "nu" ) ) )
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 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 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 _init__fvPatch__DimensionedField_scalar_volMesh( self, *args ) :
if len( args ) != 2 :
raise AssertionError( "len( args ) != 2" )
argc = 0
from Foam.finiteVolume import fvPatch
try:
fvPatch.ext_isinstance( args[ argc ] )
except TypeError:
raise AssertionError( "args[ argc ].__class__ != fvPatch" )
p = args[ argc ]; argc += 1
from Foam.finiteVolume import DimensionedField_scalar_volMesh
try:
DimensionedField_scalar_volMesh.ext_isinstance( args[ argc ] )
except TypeError:
raise AssertionError( "args[ argc ].__class__ != DimensionedField_scalar_volMesh" )
iF = args[ argc ]; argc += 1
mixedFvPatchScalarField.__init__( self, p, iF )
from Foam.OpenFOAM import word
self.neighbourFieldName_ = word( "undefined-neighbourFieldName" )
self.KName_ = word( "undefined-K" )
self.refValue().ext_assign( 0.0 )
self.refGrad().ext_assign( 0.0 )
self.valueFraction().ext_assign( 1.0 )
self.fixesValue_ = True
return self
def alphaEqn( mesh, phi, alpha1, rhoPhi, rho1, rho2, interface, nAlphaCorr ):
from Foam.OpenFOAM import word
alphaScheme = word( "div(phi,alpha)" )
alpharScheme = word( "div(phirb,alpha)" )
from Foam.finiteVolume import surfaceScalarField
phic = surfaceScalarField( ( phi / mesh.magSf() ).mag() )
phic.ext_assign( ( interface.cAlpha() * phic ).ext_min( phic.ext_max() ) )
phir = phic * interface.nHatf()
from Foam import fvc
from Foam import MULES
for aCorr in range( nAlphaCorr ):
phiAlpha = fvc.flux( phi, alpha1, alphaScheme ) + fvc.flux( -fvc.flux( -phir, 1.0 - alpha1, alpharScheme ), alpha1, alpharScheme )
MULES.explicitSolve( alpha1, phi, phiAlpha, 1.0, 0.0 )
rhoPhi.ext_assign( phiAlpha * ( rho1 - rho2 ) + phi * rho2 )
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() \
<< " Max(alpha1) = " << alpha1.ext_max().value() << nl
pass
def _init__fvPatch__DimensionedField_vector_volMesh( self, *args ) :
if len( args ) != 2 :
raise AssertionError( "len( args ) != 2" )
argc = 0
from Foam.finiteVolume import fvPatch
try:
fvPatch.ext_isinstance( args[ argc ] )
except TypeError:
raise AssertionError( "args[ argc ].__class__ != fvPatch" )
p = args[ argc ]; argc += 1
from Foam.finiteVolume import DimensionedField_vector_volMesh
try:
DimensionedField_vector_volMesh.ext_isinstance( args[ argc ] )
except TypeError:
raise AssertionError( "args[ argc ].__class__ != DimensionedField_Vector_volMesh" )
iF = args[ argc ]; argc += 1
fixedGradientFvPatchVectorField.__init__( self, p, iF )
from Foam.OpenFOAM import word
from Foam.OpenFOAM import vectorField, vector, scalarField
self.UName_ = word( "undefined" )
self.rheologyName_ = word( "undefined" )
self.traction_ = vectorField( p.size(), vector.zero)
self.pressure_ = scalarField(p.size(), 0.0)
return self
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 _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 _readCode( self, the_dict, the_prefix ) :
from Foam.OpenFOAM import word
a_code_prefix = word( the_prefix + 'Code' )
an_is_string = the_dict.found( a_code_prefix )
from Foam.OpenFOAM import word
a_file_prefix = word( the_prefix + 'File' )
an_is_file = the_dict.found( a_file_prefix )
if an_is_string and an_is_file :
raise AssertionError()
a_string = ''
if an_is_string :
from Foam.src.OpenFOAM.primitives.strings.string import string
a_string = str( string( the_dict.lookup( a_code_prefix ) ) )
elif an_is_file :
from Foam.src.OpenFOAM.primitives.strings.string import string
a_filename = str( string( the_dict.lookup( a_file_prefix ) ) )
import os.path
if not os.path.isfile( a_filename ) :
raise AssertionError()
a_file = open( a_filename )
a_string = a_file.readlines().join( '\n' )
pass
return a_string
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 _pEqn( rho, thermo, UEqn, nNonOrthCorr, psi, U, mesh, phi, p, cumulativeContErr ):
from Foam.finiteVolume import volScalarField
rUA = 1.0/UEqn.A()
U.ext_assign( rUA*UEqn.H() )
from Foam import fvc
from Foam.finiteVolume import surfaceScalarField
from Foam.OpenFOAM import word
phid = surfaceScalarField( word( "phid" ),
fvc.interpolate( thermo.psi() ) * ( (fvc.interpolate( U ) & mesh.Sf() ) + fvc.ddtPhiCorr( rUA, rho, U, phi ) ) )
for nonOrth in range( nNonOrthCorr + 1 ) :
from Foam import fvm
pEqn = ( fvm.ddt(psi, p) + fvm.div(phid, word( "div(phid,p)" ) ) - fvm.laplacian(rho*rUA, p) )
pEqn.solve()
if (nonOrth == nNonOrthCorr) :
phi.ext_assign( pEqn.flux() )
pass
pass
from Foam.finiteVolume.cfdTools.compressible import rhoEqn
rhoEqn( rho, phi )
from Foam.finiteVolume.cfdTools.compressible import compressibleContinuityErrs
cumulativeContErr = compressibleContinuityErrs( rho, thermo, cumulativeContErr )
U.ext_assign( U - rUA * fvc.grad(p) )
U.correctBoundaryConditions()
return cumulativeContErr
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 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 write( self, os ) :
mixedFvPatchScalarField.write( self, os )
from Foam.OpenFOAM import keyType, word, token
os.writeKeyword( keyType( word( "neighbourFieldName" ) ) ) << self.neighbourFieldName_ << token( token.END_STATEMENT ) << nl
os.writeKeyword( keyType( word( "K" ) ) ) << self.KName_ << token( token.END_STATEMENT ) << nl
pass
def alphaEqnSubCycle( runTime, piso, mesh, phi, alpha1, rho, rhoPhi, rho1, rho2, interface ):
from Foam.OpenFOAM import word,readLabel
nAlphaCorr = readLabel( piso.lookup( word( "nAlphaCorr" ) ) )
nAlphaSubCycles = readLabel( piso.lookup( word( "nAlphaSubCycles" ) ) )
if (nAlphaSubCycles > 1):
totalDeltaT = runTime.deltaT()
rhoPhiSum = 0.0 * rhoPhi
from Foam.finiteVolume import subCycle_volScalarField
alphaSubCycle = subCycle_volScalarField(alpha1, nAlphaSubCycles)
for item in alphaSubCycle:
alphaEqn( mesh, phi, alpha1, rhoPhi, rho1, rho2, interface, nAlphaCorr )
rhoPhiSum.ext_assign( rhoPhiSum + ( runTime.deltaT() / totalDeltaT ) * rhoPhi )
pass
# To make sure that variable in the local scope will be destroyed
# - during destruction of this variable it performs some important actions
# - there is a difference between C++ and Python memory management, namely
# if C++ automatically destroys stack variables when they exit the scope,
# Python relay its memory management of some "garbage collection" algorithm
# that do not provide predictable behavior on the "exit of scope"
del alphaSubCycle
rhoPhi.ext_assign( rhoPhiSum )
else:
alphaEqn( mesh, phi, alpha1, rhoPhi, rho1, rho2, interface, nAlphaCorr )
pass
interface.correct()
rho == alpha1 * rho1 + ( 1.0 - alpha1 ) * rho2
pass
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 main_standalone( argc, argv ):
from Foam.OpenFOAM import argList, word
argList.validOptions.fget().insert( word( "writep" ), "" )
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 )
p, U, phi, pRefCell, pRefValue = _createFields( runTime, mesh )
from Foam.OpenFOAM import ext_Info, nl
ext_Info() << nl << "Calculating potential flow" << nl
from Foam.finiteVolume.cfdTools.general.include import readSIMPLEControls
simple, nNonOrthCorr, momentumPredictor, fluxGradp, transonic = readSIMPLEControls( mesh )
from Foam.finiteVolume import adjustPhi
adjustPhi(phi, U, p)
from Foam.OpenFOAM import dimensionedScalar, word, dimTime, dimensionSet
from Foam import fvc, fvm
for nonOrth in range( nNonOrthCorr + 1):
pEqn = fvm.laplacian( dimensionedScalar( word( "1" ), dimTime / p.dimensions() * dimensionSet( 0.0, 2.0, -2.0, 0.0, 0.0 ), 1.0 ), p ) == fvc.div( phi )
pEqn.setReference( pRefCell, pRefValue )
pEqn.solve()
if nonOrth == nNonOrthCorr:
phi.ext_assign( phi - pEqn.flux() )
pass
pass
ext_Info() << "continuity error = " << fvc.div( phi ).mag().weightedAverage( mesh.V() ).value() << nl
U.ext_assign( fvc.reconstruct( phi ) )
U.correctBoundaryConditions()
ext_Info() << "Interpolated U error = " << ( ( ( fvc.interpolate( U ) & mesh.Sf() ) - phi ).sqr().sum().sqrt() /mesh.magSf().sum() ).value() << nl
# Force the write
U.write()
phi.write()
if args.optionFound( word( "writep" ) ):
p.write()
pass
ext_Info() << "ExecutionTime = " << runTime.elapsedCpuTime() << " s" << \
" ClockTime = " << runTime.elapsedClockTime() << " s" << nl << nl
ext_Info() << "End\n" << nl
import os
return os.EX_OK
def _pEqn( runTime, mesh, UEqn, thermo, p, psi, U, rho, phi, DpDt, g, initialMass, totalVolume, corr, nCorr, nNonOrthCorr, cumulativeContErr ):
closedVolume = p.needReference()
rho.ext_assign( thermo.rho() )
# Thermodynamic density needs to be updated by psi*d(p) after the
# pressure solution - done in 2 parts. Part 1:
thermo.rho().ext_assign( thermo.rho() - psi * p )
rUA = 1.0/UEqn.A()
from Foam.OpenFOAM import word
from Foam.finiteVolume import surfaceScalarField
from Foam import fvc
rhorUAf = surfaceScalarField( word( "(rho*(1|A(U)))" ), fvc.interpolate( rho * rUA ) )
U.ext_assign( rUA * UEqn.H() )
phiU = fvc.interpolate( rho ) * ( (fvc.interpolate( U ) & mesh.Sf() ) + fvc.ddtPhiCorr( rUA, rho, U, phi ) )
phi.ext_assign( phiU + rhorUAf * fvc.interpolate( rho ) * (g & mesh.Sf() ) )
for nonOrth in range( nNonOrthCorr+1 ):
from Foam import fvm
from Foam.finiteVolume import correction
pEqn = fvc.ddt( rho ) + psi * correction( fvm.ddt( p ) ) + fvc.div( phi ) - fvm.laplacian( rhorUAf, p )
if corr == nCorr-1 and nonOrth == nNonOrthCorr:
pEqn.solve( mesh.solver( word( str( p.name() ) + "Final" ) ) )
pass
else:
pEqn.solve( mesh.solver( p.name() ) )
pass
if nonOrth == nNonOrthCorr:
phi.ext_assign( phi + pEqn.flux() )
pass
# Second part of thermodynamic density update
thermo.rho().ext_assign( thermo.rho() + psi * p )
U.ext_assign( U + rUA * fvc.reconstruct( ( phi - phiU ) / rhorUAf ) )
U.correctBoundaryConditions()
DpDt.ext_assign( fvc.DDt( surfaceScalarField( word( "phiU" ), phi / fvc.interpolate( rho ) ), p ) )
from Foam.finiteVolume.cfdTools.compressible import rhoEqn
rhoEqn( rho, phi )
from Foam.finiteVolume.cfdTools.compressible import compressibleContinuityErrs
cumulativeContErr = compressibleContinuityErrs( rho, thermo, cumulativeContErr )
# For closed-volume cases adjust the pressure and density levels
# to obey overall mass continuity
if closedVolume:
p.ext_assign( p + ( initialMass - fvc.domainIntegrate( psi * p ) ) / fvc.domainIntegrate( psi ) )
thermo.rho().ext_assign( psi * p )
rho.ext_assign( rho + ( initialMass - fvc.domainIntegrate( rho ) ) / totalVolume )
pass
return cumulativeContErr
def fun_pEqn( i, mesh, p, rho, turb, thermo, thermoFluid, K, UEqn, U, phi, psi, DpDt, initialMass, p_rgh, gh, ghf, \
nNonOrthCorr, oCorr, nOuterCorr, corr, nCorr, cumulativeContErr ) :
closedVolume = p_rgh.needReference()
rho.ext_assign( thermo.rho() )
rUA = 1.0 / UEqn.A()
from Foam import fvc
from Foam.OpenFOAM import word
from Foam.finiteVolume import surfaceScalarField
rhorUAf = surfaceScalarField( word( "(rho*(1|A(U)))" ) , fvc.interpolate( rho * rUA ) )
U.ext_assign( rUA * UEqn.H() )
from Foam import fvc
phiU = ( fvc.interpolate( rho ) *
( ( fvc.interpolate( U ) & mesh.Sf() ) +
fvc.ddtPhiCorr( rUA, rho, U, phi ) ) )
phi.ext_assign( phiU - rhorUAf * ghf * fvc.snGrad( rho ) * mesh.magSf() )
from Foam import fvm
for nonOrth in range ( nNonOrthCorr + 1 ):
p_rghEqn = ( fvm.ddt( psi, p_rgh) + fvc.ddt( psi, rho ) * gh + fvc.div( phi ) - fvm.laplacian( rhorUAf, p_rgh ) )
p_rghEqn.solve( mesh.solver( p_rgh.select( ( oCorr == nOuterCorr-1 and corr == ( nCorr-1 ) and nonOrth == nNonOrthCorr ) ) ) )
if nonOrth == nNonOrthCorr :
phi.ext_assign( phi + p_rghEqn.flux() )
pass
pass
# Correct velocity field
U.ext_assign( U + rUA * fvc.reconstruct( ( phi - phiU ) / rhorUAf ) )
U.correctBoundaryConditions()
p.ext_assign( p_rgh + rho * gh )
#Update pressure substantive derivative
DpDt.ext_assign( fvc.DDt( surfaceScalarField( word( "phiU" ), phi / fvc.interpolate( rho ) ), p ) )
# Solve continuity
from Foam.finiteVolume.cfdTools.compressible import rhoEqn
rhoEqn( rho, phi )
# Update continuity errors
cumulativeContErr = compressibleContinuityErrors( i, mesh, rho, thermo, cumulativeContErr )
# For closed-volume cases adjust the pressure and density levels
# to obey overall mass continuity
if closedVolume :
p.ext_assign( p + ( initialMass - fvc.domainIntegrate( psi * p ) ) / fvc.domainIntegrate( psi ) )
rho.ext_assign( thermo.rho() )
p_rgh.ext_assign( p - rho * gh )
pass
#Update thermal conductivity
K.ext_assign( thermoFluid[ i ].Cp() * turb.alphaEff() )
return cumulativeContErr
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 _UEqn(phi, U, p, turbulence, pZones, pressureImplicitPorosity, nUCorr, eqnResidual, maxResidual):
from Foam import fvm, fvc
# Construct the Momentum equation
# The initial C++ expression does not work properly, because of
# 1. turbulence.divDevRhoReff( U ) - changes values for the U boundaries
# 2. the order of expression arguments computation differs with C++
# UEqn = fvm.div( phi, U ) - fvm.Sp( fvc.div( phi ), U ) + turbulence.divDevRhoReff( U )
UEqn = turbulence.divDevRhoReff(U) + (fvm.div(phi, U) - fvm.Sp(fvc.div(phi), U))
UEqn.relax()
# Include the porous media resistance and solve the momentum equation
# either implicit in the tensorial resistance or transport using by
# including the spherical part of the resistance in the momentum diagonal
trAU = None
trTU = None
if pressureImplicitPorosity:
from Foam.OpenFOAM import sphericalTensor, tensor
tTU = tensor(sphericalTensor.I) * UEqn.A()
pZones.addResistance(UEqn, tTU)
trTU = tTU.inv()
from Foam.OpenFOAM import word
trTU.rename(word("rAU"))
for UCorr in range(nUCorr):
U.ext_assign(trTU & (UEqn.H() - fvc.grad(p)))
pass
U.correctBoundaryConditions()
else:
pZones.addResistance(UEqn)
from Foam.finiteVolume import solve
eqnResidual = solve(UEqn == -fvc.grad(p)).initialResidual()
maxResidual = max(eqnResidual, maxResidual)
trAU = 1.0 / UEqn.A()
from Foam.OpenFOAM import word
trAU.rename(word("rAU"))
pass
return UEqn, trTU, trAU, eqnResidual, maxResidual
def readSolidMultiRegionPISOControls( mesh ):
from Foam.OpenFOAM import word, readInt
piso = mesh.solutionDict().subDict( word( "PISO" ) )
nNonOrthCorr = 0
if piso.found( word( "nNonOrthogonalCorrectors" ) ):
nNonOrthCorr = readInt( piso.lookup( word( "nNonOrthogonalCorrectors" ) ) )
return piso, nNonOrthCorr
def readFluidMultiRegionPIMPLEControls( mesh ) :
from Foam.OpenFOAM import word, readInt, Switch
pimple = mesh.solutionDict().subDict( word( "PIMPLE" ) )
nCorr = readInt( pimple.lookup( word( "nCorrectors" ) ) )
nNonOrthCorr = pimple.lookupOrDefault( word( "nNonOrthogonalCorrectors" ), 0 )
momentumPredictor =pimple.lookupOrDefault( word( "momentumPredictor" ), Switch( True ) )
return pimple, nCorr, nNonOrthCorr, momentumPredictor
def fun_pEqn( runTime, mesh, p, phi, U, UEqn, g, rhok, eqnResidual, maxResidual, nNonOrthCorr, cumulativeContErr, pRefCell, pRefValue ):
from Foam.finiteVolume import volScalarField, surfaceScalarField
from Foam.OpenFOAM import word
from Foam import fvc
rUA = volScalarField( word( "rUA" ), 1.0 / UEqn().A() )
rUAf = surfaceScalarField(word( "(1|A(U))" ), fvc.interpolate( rUA ) )
U.ext_assign( rUA * UEqn().H() )
UEqn.clear()
from Foam import fvc
phi.ext_assign( fvc.interpolate( U ) & mesh.Sf() )
from Foam.finiteVolume import adjustPhi
adjustPhi( phi, U, p )
buoyancyPhi = rUAf * fvc.interpolate( rhok ) * ( g & mesh.Sf() )
phi.ext_assign( phi + buoyancyPhi )
for nonOrth in range( nNonOrthCorr+1 ):
from Foam import fvm, fvc
pEqn = fvm.laplacian(rUAf, p) == fvc.div(phi)
pEqn.setReference( pRefCell, pRefValue )
# retain the residual from the first iteration
if ( nonOrth == 0 ):
eqnResidual = pEqn.solve().initialResidual()
maxResidual = max( eqnResidual, maxResidual )
pass
else:
pEqn.solve()
pass
if ( nonOrth == nNonOrthCorr ):
# Calculate the conservative fluxes
phi.ext_assign( phi - pEqn.flux() )
# Explicitly relax pressure for momentum corrector
p.relax()
# Correct the momentum source with the pressure gradient flux
# calculated from the relaxed pressure
U.ext_assign( U + rUA * fvc.reconstruct( ( buoyancyPhi - pEqn.flux() ) / rUAf ) )
U.correctBoundaryConditions()
pass
pass
from Foam.finiteVolume.cfdTools.incompressible import continuityErrs
cumulativeContErr = continuityErrs( mesh, phi, runTime, cumulativeContErr )
return eqnResidual, maxResidual, cumulativeContErr
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
def readPIMPLEControls( runTime ):
from Foam.finiteVolume import fvSolution
solutionDict = fvSolution( runTime )
from Foam.OpenFOAM import word,readInt
pimple = solutionDict.subDict( word( "PIMPLE" ) )
nOuterCorr = readInt( pimple.lookup( word( "nOuterCorrectors" ) ) )
return nOuterCorr
def fun_pEqn( mesh, p, rho, psi, p_rgh, U, phi, ghf, gh, DpDt, UEqn, thermo, nNonOrthCorr, corr, nCorr, finalIter, cumulativeContErr ):
rho.ext_assign( thermo.rho() )
# Thermodynamic density needs to be updated by psi*d(p) after the
# pressure solution - done in 2 parts. Part 1:
thermo.rho().ext_assign( thermo.rho() - psi * p_rgh )
rUA = 1.0 / UEqn.A()
from Foam.finiteVolume import surfaceScalarField
from Foam.OpenFOAM import word
from Foam import fvc
rhorUAf = surfaceScalarField( word( "(rho*(1|A(U)))" ), fvc.interpolate( rho * rUA ) )
U.ext_assign( rUA*UEqn.H() )
phi.ext_assign( fvc.interpolate( rho ) * ( ( fvc.interpolate( U ) & mesh.Sf() ) + fvc.ddtPhiCorr( rUA, rho, U, phi ) ) )
buoyancyPhi = -rhorUAf * ghf * fvc.snGrad( rho ) * mesh.magSf()
phi.ext_assign( phi + buoyancyPhi )
from Foam import fvm
from Foam.finiteVolume import correction
for nonOrth in range( nNonOrthCorr +1 ):
p_rghEqn = fvc.ddt( rho ) + psi * correction( fvm.ddt( p_rgh ) ) + fvc.div( phi ) - fvm.laplacian( rhorUAf, p_rgh )
p_rghEqn.solve( mesh.solver( p_rgh.select( ( finalIter and corr == nCorr-1 and nonOrth == nNonOrthCorr ) ) ) )
if nonOrth == nNonOrthCorr:
# Calculate the conservative fluxes
phi.ext_assign( phi + p_rghEqn.flux() )
# Explicitly relax pressure for momentum corrector
p_rgh.relax()
# Correct the momentum source with the pressure gradient flux
# calculated from the relaxed pressure
U.ext_assign( U + rUA * fvc.reconstruct( ( buoyancyPhi + p_rghEqn.flux() ) / rhorUAf ) )
U.correctBoundaryConditions()
pass
p.ext_assign( p_rgh + rho * gh )
# Second part of thermodynamic density update
thermo.rho().ext_assign( thermo.rho() + psi * p_rgh )
DpDt.ext_assign( fvc.DDt( surfaceScalarField( word( "phiU" ), phi / fvc.interpolate( rho ) ), p ) )
from Foam.finiteVolume.cfdTools.compressible import rhoEqn
rhoEqn( rho, phi )
from Foam.finiteVolume.cfdTools.compressible import compressibleContinuityErrs
cumulativeContErr = compressibleContinuityErrs( rho, thermo, cumulativeContErr )
return cumulativeContErr
def readTransportProperties( U, phi ):
from Foam.transportModels import singlePhaseTransportModel
laminarTransport = singlePhaseTransportModel( U, phi )
from Foam.OpenFOAM import dimensionedScalar, word
# Thermal expansion coefficient [1/K]
beta = dimensionedScalar( laminarTransport.lookup( word( "beta" ) ) )
# Reference temperature [K]
TRef = dimensionedScalar( laminarTransport.lookup( word( "TRef" ) ) )
# Laminar Prandtl number
Pr = dimensionedScalar( laminarTransport.lookup( word( "Pr" ) ) )
# Turbulent Prandtl number
Prt = dimensionedScalar( laminarTransport.lookup( word( "Prt" ) ) )
return laminarTransport, beta, TRef,Pr, Prt
def initConvergenceCheck( simple ):
eqnResidual = 1
maxResidual = 0
convergenceCriterion = 0
from Foam.OpenFOAM import word
tmp, convergenceCriterion = simple.readIfPresent( word( "convergence" ), convergenceCriterion )
return eqnResidual, maxResidual, convergenceCriterion
def write(self, os):
try:
from Foam.finiteVolume import fvPatchVectorField
fvPatchVectorField.write(self, os)
from Foam.OpenFOAM import word, token
os.writeKeyword(word("U")) << self.UName_ << token(
token.END_STATEMENT) << nl
os.writeKeyword(word("rheology")) << self.rheologyName_ << token(
token.END_STATEMENT) << nl
self.traction_.writeEntry(word("traction"), os)
self.pressure_.writeEntry(word("pressure"), os)
self.writeEntry(word("value"), os)
pass
except Exception, exc:
import sys, traceback
traceback.print_exc(file=sys.stdout)
raise exc
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 _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 read_controls( args, runTime, mesh ):
from Foam.finiteVolume.cfdTools.general.include import readPISOControls
piso, nCorr, nNonOrthCorr, momentumPredictor, transonic, nOuterCorr = readPISOControls( mesh )
from Foam.finiteVolume.cfdTools.general.include import readTimeControls
adjustTimeStep, maxCo, maxDeltaT = readTimeControls( runTime )
from Foam.OpenFOAM import word, readLabel
nAlphaCorr = readLabel( piso.lookup( word( "nAlphaCorr" ) ) )
nAlphaSubCycles = readLabel( piso.lookup( word( "nAlphaSubCycles" ) ) )
if nAlphaSubCycles > 1 and nOuterCorr != 1:
from Foam.OpenFOAM import ext_Info, nl
ext_Info() << args.executable() << "FATAL ERROR: Sub-cycling alpha is only allowed for PISO, i.e. when the number of outer-correctors = 1" << nl;
import os; os_exit( 1 )
pass
return piso, nCorr, nNonOrthCorr, momentumPredictor, transonic, nOuterCorr, adjustTimeStep, maxCo, maxDeltaT, nAlphaCorr, nAlphaSubCycles
def readFluxScheme(mesh):
from Foam.OpenFOAM import word
fluxScheme = word("Kurganov")
if mesh.schemesDict().found(word("fluxScheme")):
fluxScheme = word(mesh.schemesDict().lookup(word("fluxScheme")))
from Foam.OpenFOAM import ext_Info, nl
if str(fluxScheme) == "Tadmor" or str(fluxScheme) == "Kurganov":
ext_Info() << "fluxScheme: " << fluxScheme << nl
pass
else:
ext_Info() << "rhoCentralFoam::readFluxScheme" \
<< "fluxScheme: " << fluxScheme \
<< " is not a valid choice. " \
<< "Options are: Tadmor, Kurganov" <<nl
import os
os.abort()
pass
pass
return fluxScheme
def readThermophysicalProperties(runTime, mesh):
from Foam.OpenFOAM import ext_Info, nl
ext_Info() << "Reading thermophysicalProperties\n" << nl
from Foam.OpenFOAM import IOdictionary, IOobject, word, fileName
# Pr defined as a separate constant to enable calculation of k, currently
# inaccessible through thermo
thermophysicalProperties = IOdictionary(
IOobject(word("thermophysicalProperties"),
fileName(runTime.constant()), mesh, IOobject.MUST_READ,
IOobject.NO_WRITE))
from Foam.OpenFOAM import dimensionedScalar, dimless
Pr = dimensionedScalar(word("Pr"), dimless, 1.0)
if thermophysicalProperties.found(word("Pr")):
Pr = thermophysicalProperties.lookup(word("Pr"))
pass
return thermophysicalProperties, Pr
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
def _init__fvPatch__DimensionedField_scalar_volMesh__dictionary( self, *args ) :
if len( args ) != 3 :
raise AssertionError( "len( args ) != 3" )
argc = 0
from Foam.finiteVolume import fvPatch
try:
fvPatch.ext_isinstance( args[ argc ] )
except TypeError:
raise AssertionError( "args[ argc ].__class__ != fvPatch" )
p = args[ argc ]; argc += 1
from Foam.finiteVolume import DimensionedField_scalar_volMesh
try:
DimensionedField_scalar_volMesh.ext_isinstance( args[ argc ] )
except TypeError:
raise AssertionError( "args[ argc ].__class__ != DimensionedField_scalar_volMesh" )
iF = 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 ]; argc += 1
mixedFvPatchScalarField.__init__( self, p, iF )
from Foam.OpenFOAM import word
self.neighbourFieldName_ = word( dict_.lookup( word( "neighbourFieldName" ) ) )
self.KName_ = word( dict_.lookup( word( "K" ) ) )
from Foam.finiteVolume import fvPatchScalarField
from Foam.OpenFOAM import word, scalarField, readBool
fvPatchScalarField.ext_assign( self, scalarField( word( "value" ), dict_, p.size() ) )
if dict_.found( word( "refValue" ) ) :
#Full restart
self.refValue().ext_assign( scalarField( word( "refValue" ), dict_, p.size() ) )
self.refGrad().ext_assign( scalarField( word( "refGradient" ), dict_, p.size() ) )
self.valueFraction().ext_assign( scalarField( word( "valueFraction" ), dict_, p.size() ) )
else:
# Start from user entered data. Assume fixedValue.
self.refValue().ext_assign( self )
self.refGrad().ext_assign( 0.0 )
self.valueFraction().ext_assign( 1.0 )
pass
return self
def alphaEqnsSubCycle( runTime, piso, mesh, phi, alpha1, alpha2, rho, rho1, rho2, rhoPhi, dgdt, interface, oCorr ):
from Foam.OpenFOAM import word,readLabel
nAlphaCorr = readLabel( piso.lookup( word( "nAlphaCorr" ) ) )
nAlphaSubCycles = readLabel( piso.lookup( word( "nAlphaSubCycles" ) ) )
from Foam.finiteVolume import surfaceScalarField
phic = ( phi / mesh.magSf() ).mag()
phic.ext_assign( ( interface.cAlpha() * phic ).ext_min( phic.ext_max() ) )
from Foam import fvc
divU = fvc.div( phi )
if nAlphaSubCycles > 1:
totalDeltaT = runTime.deltaT()
rhoPhiSum = 0.0 * rhoPhi
from Foam.finiteVolume import subCycle_volScalarField
alphaSubCycle = subCycle_volScalarField( alpha1, nAlphaSubCycles )
for item in alphaSubCycle:
alphaEqns( runTime, mesh, rho1, rho2, rhoPhi, phic, dgdt, divU, alpha1, alpha2, phi, interface, nAlphaCorr )
rhoPhiSum.ext_assign( rhoPhiSum + ( runTime.deltaT() / totalDeltaT ) * rhoPhi )
pass
# To make sure that variable in the local scope will be destroyed
# - during destruction of this variable it performs some important actions
# - there is a difference between C++ and Python memory management, namely
# if C++ automatically destroys stack variables when they exit the scope,
# Python relay its memory management of some "garbage collection" algorithm
# that do not provide predictable behavior on the "exit of scope"
del alphaSubCycle
rhoPhi.ext_assign( rhoPhiSum )
pass
else:
alphaEqns( runTime, mesh, rho1, rho2, rhoPhi, phic, dgdt, divU, alpha1, alpha2, phi, interface, nAlphaCorr )
pass
if oCorr == 0:
interface.correct()
pass
pass
def __init__(self, name, sigma, dict_):
from Foam.OpenFOAM import word, dictionary
from Foam.finiteVolume import volSymmTensorField
try:
name = word(str(name))
except ValueError:
raise AttributeError("The second arg is not string")
try:
volSymmTensorField.ext_isinstance(sigma)
except TypeError:
raise AssertionError("sigma != volSymmTensorField")
from Foam.OpenFOAM import dictionary
try:
dictionary.ext_isinstance(dict_)
except TypeError:
raise AssertionError("dict_ != dictionary")
rheologyLaw.__init__(self, name, sigma, dict_)
from Foam.OpenFOAM import IOobject, fileName
from Foam.finiteVolume import volScalarField
self.materials_ = volScalarField(
IOobject(word("materials"),
fileName(self.mesh().time().timeName()), self.mesh(),
IOobject.MUST_READ, IOobject.AUTO_WRITE), self.mesh())
from Foam.OpenFOAM import PtrList_entry
lawEntries = PtrList_entry(dict_.lookup(word("laws")))
for lawI in range(lawEntries.size()):
self.append(
rheologyLaw.New(lawEntries[lawI].keyword(), sigma,
lawEntries[lawI].dict()))
from Foam.OpenFOAM import SMALL
if self.materials_.ext_min().value() < 0 or self.materials_.ext_max(
).value() > (len(self) + SMALL):
raise IOError(" Invalid definition of material indicator field.")
pass
def _init__fvPatch(self, *args):
if len(args) != 1:
raise AssertionError("len( args ) != 1")
argc = 0
from Foam.finiteVolume import fvPatch
try:
fvPatch.ext_isinstance(args[argc])
except TypeError:
raise AssertionError("args[ argc ].__class__ != fvPatch")
patch = args[argc]
self.patch_ = patch
from Foam.OpenFOAM import word
self.neighbourRegionName_ = word("undefined-neighbourRegionName")
self.neighbourPatchName_ = word("undefined-neighbourPatchName")
self.neighbourFieldName_ = word("undefined-neighbourFieldName")
self.localRegion_ = self.patch_.boundaryMesh().mesh()
return self
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 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 readTransportProperties(runTime, mesh):
from Foam.OpenFOAM import ext_Info, nl
from Foam.OpenFOAM import IOdictionary, IOobject, word, fileName
ext_Info() << "\nReading transportProperties\n" << nl
transportProperties = IOdictionary(
IOobject(word("transportProperties"), fileName(runTime.constant()),
mesh, IOobject.MUST_READ, IOobject.NO_WRITE, False))
from Foam.OpenFOAM import dimensionedScalar, dimensionedVector
nu = dimensionedScalar(transportProperties.lookup(word("nu")))
# Read centerline velocity for channel simulations
Ubar = dimensionedVector(transportProperties.lookup(word("Ubar")))
magUbar = Ubar.mag()
from Foam.OpenFOAM import vector
flowDirection = (Ubar / magUbar).ext_value()
return transportProperties, nu, Ubar, magUbar, flowDirection
def read( self ):
from Foam.OpenFOAM import regIOobject
if regIOobject.read( self ):
self.lookup("planeStress") >> self.planeStress_
from Foam.OpenFOAM import word
from materialModels.rheologyModel.rheologyLaws import rheologyLaw
self.lawPtr_ = rheologyLaw.New( word( "law" ), self.sigma_, self.subDict("rheology"));
return True
else:
return False
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)
p = thermo.p()
e = thermo.e()
T = thermo.T()
psi = thermo.psi()
mu = thermo.mu()
inviscid = True
if mu.internalField().max() > 0.0:
inviscid = False
pass
ext_Info() << "Reading field U\n" << nl
from Foam.OpenFOAM import IOdictionary, IOobject, word, fileName
from Foam.finiteVolume import volVectorField
U = volVectorField(
IOobject(word("U"), fileName(runTime.timeName()), mesh,
IOobject.MUST_READ, IOobject.AUTO_WRITE), mesh)
pbf, rhoBoundaryTypes = _rhoBoundaryTypes(p)
from Foam.finiteVolume import volScalarField
rho = volScalarField(
IOobject(word("rho"), fileName(runTime.timeName()), mesh,
IOobject.NO_READ, IOobject.AUTO_WRITE), thermo.rho(),
rhoBoundaryTypes)
rhoU = volVectorField(
IOobject(word("rhoU"), fileName(runTime.timeName()), mesh,
IOobject.NO_READ, IOobject.NO_WRITE), rho * U)
rhoE = volScalarField(
IOobject(word("rhoE"), fileName(runTime.timeName()), mesh,
IOobject.NO_READ, IOobject.NO_WRITE),
rho * (e + 0.5 * U.magSqr()))
from Foam.OpenFOAM import dimensionedScalar, dimless
from Foam.finiteVolume import surfaceScalarField
pos = surfaceScalarField(
IOobject(word("pos"), fileName(runTime.timeName()), mesh), mesh,
dimensionedScalar(word("pos"), dimless, 1.0))
neg = surfaceScalarField(
IOobject(word("neg"), fileName(runTime.timeName()), mesh), mesh,
dimensionedScalar(word("neg"), dimless, -1.0))
return thermo, p, e, T, psi, mu, U, pbf, rhoBoundaryTypes, rho, rhoU, rhoE, pos, neg, inviscid
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 _pEqn(mesh, UEqn, U, p, pd, phi, alpha1, rho, ghf, interface, corr, nCorr,
nNonOrthCorr, pdRefCell, pdRefValue):
rUA = 1.0 / UEqn.A()
from Foam import fvc
rUAf = fvc.interpolate(rUA)
U.ext_assign(rUA * UEqn.H())
from Foam.finiteVolume import surfaceScalarField
from Foam.OpenFOAM import word
phiU = surfaceScalarField(word("phiU"), (fvc.interpolate(U) & mesh.Sf()) +
fvc.ddtPhiCorr(rUA, rho, U, phi))
from Foam.finiteVolume import adjustPhi
adjustPhi(phiU, U, p)
phi.ext_assign(phiU +
(fvc.interpolate(interface.sigmaK()) * fvc.snGrad(alpha1) -
ghf * fvc.snGrad(rho)) * rUAf * mesh.magSf())
from Foam import fvm
for nonOrth in range(nNonOrthCorr + 1):
pdEqn = fvm.laplacian(rUAf, pd) == fvc.div(phi)
pdEqn.setReference(pdRefCell, pdRefValue)
if corr == nCorr - 1 and nonOrth == nNonOrthCorr:
pdEqn.solve(mesh.solver(word(str(pd.name()) + "Final")))
pass
else:
pdEqn.solve(mesh.solver(pd.name()))
pass
if nonOrth == nNonOrthCorr:
phi.ext_assign(phi - pdEqn.flux())
pass
pass
U.ext_assign(U + rUA * fvc.reconstruct((phi - phiU) / rUAf))
U.correctBoundaryConditions()
pass
def sigmaY(self):
from Foam.finiteVolume import volScalarField, zeroGradientFvPatchScalarField
from Foam.OpenFOAM import word, fileName, IOobject, dimensionedScalar, dimForce, dimArea, GREAT
result = 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)
#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_sigmaY = lawI.sigmaY()
result.internalField().ext_assign( result.internalField() + \
self.indicator( lawI ) * lawI_sigmaY.internalField() )
result.correctBoundaryConditions()
return result
def readControls(runTime, mesh):
from Foam.finiteVolume.cfdTools.general.include import readTimeControls
adjustTimeStep, maxCo, maxDeltaT = readTimeControls(runTime)
from Foam.finiteVolume.cfdTools.general.include import readPIMPLEControls
pimple, nOuterCorr, nCorr, nNonOrthCorr, momentumPredictor, transonic = readPIMPLEControls(
mesh)
correctPhi = False
from Foam.OpenFOAM import word
if (pimple.found(word("correctPhi"))):
correctPhi = Switch(pimple.lookup(word("correctPhi")))
pass
checkMeshCourantNo = False
if (pimple.found(word("checkMeshCourantNo"))):
checkMeshCourantNo = Switch(pimple.lookup("checkMeshCourantNo"))
pass
return adjustTimeStep, maxCo, maxDeltaT, pimple, nOuterCorr, nCorr, nNonOrthCorr, \
momentumPredictor, transonic, correctPhi, checkMeshCourantNo
def createPhi(runTime, hU, mesh):
from Foam.OpenFOAM import ext_Info, nl
from Foam.OpenFOAM import IOdictionary, IOobject, word, fileName
from Foam.finiteVolume import surfaceScalarField
ext_Info() << "Reading/calculating face flux field phi\n" << nl
from Foam.finiteVolume import linearInterpolate
phi = surfaceScalarField(
IOobject(word("phi"), fileName(runTime.timeName()), mesh,
IOobject.READ_IF_PRESENT, IOobject.AUTO_WRITE),
linearInterpolate(hU) & mesh.Sf())
return phi
def _pEqn(runTime, mesh, U, UEqn, phi, p, rhok, g, corr, nCorr, nNonOrthCorr,
cumulativeContErr):
from Foam.finiteVolume import volScalarField, surfaceScalarField
from Foam.OpenFOAM import word
from Foam import fvc
rUA = volScalarField(word("rUA"), 1.0 / UEqn.A())
rUAf = surfaceScalarField(word("(1|A(U))"), fvc.interpolate(rUA))
U.ext_assign(rUA * UEqn.H())
phiU = (fvc.interpolate(U) & mesh.Sf()) + fvc.ddtPhiCorr(rUA, U, phi)
phi.ext_assign(phiU + rUAf * fvc.interpolate(rhok) * (g & mesh.Sf()))
for nonOrth in range(nNonOrthCorr + 1):
from Foam import fvm
pEqn = fvm.laplacian(rUAf, p) == fvc.div(phi)
if (corr == nCorr - 1) and (nonOrth == nNonOrthCorr):
from Foam.OpenFOAM import word
pEqn.solve(mesh.solver(word(str(p.name()) + "Final")))
pass
else:
pEqn.solve(mesh.solver(p.name()))
pass
if (nonOrth == nNonOrthCorr):
phi.ext_assign(phi - pEqn.flux())
pass
pass
U.ext_assign(U + rUA * fvc.reconstruct((phi - phiU) / rUAf))
U.correctBoundaryConditions()
from Foam.finiteVolume.cfdTools.incompressible import continuityErrs
cumulativeContErr = continuityErrs(mesh, phi, runTime, cumulativeContErr)
return pEqn
def updateCoeffs(self):
try:
if self.updated():
return
from Foam.finiteVolume import volScalarField
from Foam.OpenFOAM import word
rhop = volScalarField.ext_lookupPatchField(self.patch(),
word("rho"))
from Foam.finiteVolume import volVectorField
rhoUp = volVectorField.ext_lookupPatchField(
self.patch(), word("rhoU"))
T = volScalarField.ext_lookupObject(self.db(), word("T"))
patchi = self.patch().index()
Tp = T.ext_boundaryField()[patchi]
Tp.evaluate()
from Foam.OpenFOAM import IOdictionary
thermodynamicProperties = IOdictionary.ext_lookupObject(
self.db(), word("thermodynamicProperties"))
from Foam.OpenFOAM import dimensionedScalar
Cv = dimensionedScalar(thermodynamicProperties.lookup(word("Cv")))
self.valueFraction().ext_assign(
rhop.ext_snGrad() /
(rhop.ext_snGrad() - rhop * self.patch().deltaCoeffs()))
self.refValue().ext_assign(0.5 * rhop * (rhoUp / rhop).magSqr())
self.refGrad().ext_assign( rhop * Cv.value() * Tp.ext_snGrad() +\
( self.refValue() - ( 0.5 * rhop.patchInternalField()\
* ( rhoUp.patchInternalField() /rhop.patchInternalField() ).magSqr() ) ) * self.patch().deltaCoeffs() )
mixedFvPatchScalarField.updateCoeffs(self)
pass
except Exception, exc:
import sys, traceback
traceback.print_exc(file=sys.stdout)
raise exc
def _createFields(runTime, mesh, Omega, gHat):
from Foam.OpenFOAM import ext_Info, nl
from Foam.OpenFOAM import IOdictionary, IOobject, word, fileName
from Foam.finiteVolume import volScalarField
ext_Info() << "Reading field h\n" << nl
h = volScalarField(
IOobject(word("h"), fileName(runTime.timeName()), mesh,
IOobject.MUST_READ, IOobject.AUTO_WRITE), mesh)
from Foam.OpenFOAM import dimLength, dimensionedScalar
ext_Info() << "Reading field h0 if present\n" << nl
h0 = volScalarField(
IOobject(
word("h0"),
fileName(
runTime.findInstance(fileName(word("polyMesh")),
word("points"))), mesh,
IOobject.READ_IF_PRESENT), mesh,
dimensionedScalar(word("h0"), dimLength, 0.0))
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)
ext_Info() << "Creating field hU\n" << nl
hU = volVectorField(
IOobject(word("hU"), fileName(runTime.timeName()), mesh), h * U,
U.ext_boundaryField().types())
ext_Info() << "Creating field hTotal for post processing\n" << nl
hTotal = volScalarField(
IOobject(word("hTotal"), fileName(runTime.timeName()), mesh,
IOobject.READ_IF_PRESENT, IOobject.AUTO_WRITE), h + h0)
hTotal.write()
phi = createPhi(runTime, hU, mesh)
ext_Info() << "Creating Coriolis Force" << nl
from Foam.OpenFOAM import dimensionedVector
F = dimensionedVector(word("F"), ((2.0 * Omega) & gHat) * gHat)
return h, h0, U, hU, hTotal, phi, F
def _init__fvPatch__dictionary(self, *args):
if len(args) != 2:
raise AssertionError("len( args ) != 1")
argc = 0
from Foam.finiteVolume import fvPatch
try:
fvPatch.ext_isinstance(args[argc])
except TypeError:
raise AssertionError("args[ argc ].__class__ != fvPatch")
patch = args[argc]
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]
self.patch_ = patch
from Foam.OpenFOAM import word
self.neighbourRegionName_ = word(
dict_.lookup(word("neighbourRegionName")))
self.neighbourPatchName_ = word(
dict_.lookup(word("neighbourPatchName")))
self.neighbourFieldName_ = word(
dict_.lookup(word("neighbourFieldName")))
self.localRegion_ = self.patch_.boundaryMesh().mesh()
return self
def _init__fvPatch__DimensionedField_scalar_volMesh__dictionary( self, *args ):
if len( args ) != 3 :
raise AssertionError( "len( args ) != 3" )
argc = 0
from Foam.finiteVolume import fvPatch
try:
fvPatch.ext_isinstance( args[ argc ] )
except TypeError:
raise AssertionError( "args[ argc ].__class__ != fvPatch" )
p = args[ argc ]; argc += 1
from Foam.finiteVolume import DimensionedField_scalar_volMesh
try:
DimensionedField_scalar_volMesh.ext_isinstance( args[ argc ] )
except TypeError:
raise AssertionError( "args[ argc ].__class__ != DimensionedField_scalar_volMesh" )
iF = 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 ]
fixedGradientFvPatchScalarField.__init__( self, p, iF )
if dict_.found( word( "gradient" ) ):
from Foam.OpenFOAM import scalarField
self.gradient().ext_assign( scalarField( word( "gradient" ) , dict_, p.size() ) )
fixedGradientFvPatchScalarField.updateCoeffs( self )
fixedGradientFvPatchScalarField.evaluate()
pass
else:
self.ext_assign( self.patchInternalField() )
self.gradient().ext_assign( 0.0 )
pass
return self
def fun_pEqn( thermo, g, rho, UEqn, p, U, psi, phi, initialMass, runTime, mesh, nNonOrthCorr, pRefCell, pRefValue, eqnResidual, maxResidual, cumulativeContErr ):
rho.ext_assign( thermo.rho() )
rUA = 1.0/UEqn.A()
from Foam.OpenFOAM import word
from Foam import fvc,fvm
from Foam.finiteVolume import surfaceScalarField
rhorUAf = surfaceScalarField(word( "(rho*(1|A(U)))" ) , fvc.interpolate(rho*rUA));
U.ext_assign(rUA*UEqn.H())
UEqn.clear()
phi.ext_assign( fvc.interpolate( rho )*(fvc.interpolate(U) & mesh.Sf()) )
from Foam.finiteVolume import adjustPhi
closedVolume = adjustPhi(phi, U, p);
buoyancyPhi =surfaceScalarField( rhorUAf * fvc.interpolate( rho )*( g & mesh.Sf() ) )
phi.ext_assign( phi+buoyancyPhi )
for nonOrth in range( nNonOrthCorr+1 ):
from Foam import fvm
pEqn = fvm.laplacian(rhorUAf, p) == fvc.div(phi)
pEqn.setReference(pRefCell, pRefValue )
if (nonOrth == 0):
eqnResidual = pEqn.solve().initialResidual()
maxResidual = max(eqnResidual, maxResidual)
else:
pEqn.solve()
if (nonOrth == nNonOrthCorr):
if (closedVolume):
p.ext_assign( p + ( initialMass - fvc.domainIntegrate( psi * p ) ) / fvc.domainIntegrate( psi ) )
phi.ext_assign( phi - pEqn.flux() )
p.relax()
U.ext_assign( U + rUA * fvc.reconstruct( ( buoyancyPhi - pEqn.flux() ) / rhorUAf ) )
U.correctBoundaryConditions();
from Foam.finiteVolume.cfdTools.general.include import ContinuityErrs
cumulativeContErr = ContinuityErrs( phi, runTime, mesh, cumulativeContErr )
rho.ext_assign( thermo.rho() )
rho.relax()
ext_Info()<< "rho max/min : " << rho.ext_max().value() << " " << rho.ext_min().value() << nl
return eqnResidual, maxResidual, cumulativeContErr
