def createFields( runTime, mesh): ref.ext_Info() << "Reading thermophysical properties\n" << ref.nl pThermo = man.basicPsiThermo.New( mesh ) p = man.volScalarField( pThermo.p(), man.Deps( pThermo ) ) e = man.volScalarField( pThermo.e(), man.Deps( pThermo ) ) psi = man.volScalarField( pThermo.psi(), man.Deps( pThermo ) ) rho = man.volScalarField( man.IOobject( ref.word( "rho" ), ref.fileName( runTime.timeName() ), mesh ), man.volScalarField( pThermo.rho(), man.Deps( pThermo ) ) ) ref.ext_Info() << "Reading field U\n" << ref.nl U = man.volVectorField( man.IOobject( ref.word( "U" ), ref.fileName( runTime.timeName() ), mesh, ref.IOobject.MUST_READ, ref.IOobject.AUTO_WRITE ), mesh ); phi = man.compressibleCreatePhi( runTime, mesh, rho, U ) ref.ext_Info() << "Creating turbulence model\n" << ref.nl turbulence = man.compressible.turbulenceModel.New( rho, U, phi, pThermo ) return pThermo, p, e, psi, rho, U, phi, turbulence
def _UEqn( phi, U, p, rho, turbulence, mrfZones, pZones, pressureImplicitPorosity, nUCorr ): # Solve the Momentum equation UEqn = man.fvVectorMatrix( turbulence.divDevRhoReff( U ), man.Deps( turbulence ) ) + man.fvm.div( phi, U ) UEqn.relax() mrfZones.addCoriolis( rho, UEqn ) trAU = None trTU = None if pressureImplicitPorosity: tTU = man.volTensorField( ref.tensor( ref.I ) * UEqn.A(), man.Deps( UEqn ) ) pZones.addResistance( UEqn, tTU ) trTU = man.volTensorField( tTU.inv(), man.Deps( tTU ) ) trTU.rename( ref.word( "rAU" ) ) gradp = ref.fvc.grad(p) for UCorr in range( nUCorr ): U << ( trTU() & ( UEqn.H() - gradp ) ) # mixed calculations pass U.correctBoundaryConditions() pass else: pZones.addResistance( UEqn ) ref.solve( UEqn == -ref.fvc.grad( p ) ) trAU = man.volScalarField( 1.0 / UEqn.A(), man.Deps( UEqn ) ) trAU.rename( ref.word( "rAU" ) ) pass return UEqn, trAU, trTU
def createFields( runTime, mesh, rhoO, psi ): ref.ext_Info()<< "Reading field p\n" << ref.nl p = man.volScalarField( man.IOobject( ref.word( "p" ), ref.fileName( runTime.timeName() ), mesh, ref.IOobject.MUST_READ, ref.IOobject.AUTO_WRITE ), mesh ) ref.ext_Info()<< "Reading field U\n" << ref.nl U = man.volVectorField( man.IOobject( ref.word( "U" ), ref.fileName( runTime.timeName() ), mesh, ref.IOobject.MUST_READ, ref.IOobject.AUTO_WRITE ), mesh ) rho = man.volScalarField( man.IOobject( ref.word( "rho" ), ref.fileName( runTime.timeName() ), mesh, ref.IOobject.NO_READ, ref.IOobject.AUTO_WRITE ), rhoO + psi * p ) phi = man.compressibleCreatePhi( runTime, mesh, U, rho ) return p, U, rho, phi
def solveFluid( i, mesh, thermo, rad, thermoFluid, rho, K, U, phi, h, turb, DpDt, p, psi, initialMass, p_rgh, gh, ghf,\ oCorr, nCorr, nOuterCorr, nNonOrthCorr, momentumPredictor,cumulativeContErr, finalIter ) : if finalIter: mesh.add( ref.word( "finalIteration" ), True ) pass if oCorr == 0 : ref.rhoEqn( rho, phi ) pass UEqn = fun_UEqn( rho, U, phi, ghf, p_rgh, turb, mesh, momentumPredictor, finalIter ) fun_hEqn( rho, h, phi, turb, DpDt, thermo, rad, mesh, oCorr, nOuterCorr, finalIter ) # --- PISO loop for corr in range( nCorr ): cumulativeContErr = 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 ) pass turb.correct() rho << thermo.rho() if finalIter: mesh.remove( ref.word( "finalIteration" ) ) pass return cumulativeContErr
def alphaEqnSubCycle(runTime, pimple, mesh, phi, alpha1, rho, rhoPhi, rho1, rho2, interface): nAlphaCorr = ref.readLabel(pimple.dict().lookup(ref.word("nAlphaCorr"))) nAlphaSubCycles = ref.readLabel(pimple.dict().lookup(ref.word("nAlphaSubCycles"))) if nAlphaSubCycles > 1: totalDeltaT = runTime.deltaT() rhoPhiSum = 0.0 * rhoPhi alphaSubCycle = ref.subCycle_volScalarField(alpha1, nAlphaSubCycles) for item in alphaSubCycle: alphaEqn(mesh, phi, alpha1, rhoPhi, rho1, rho2, interface, nAlphaCorr) rhoPhiSum << 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 << rhoPhiSum else: alphaEqn(mesh, phi, alpha1, rhoPhi, rho1, rho2, interface, nAlphaCorr) pass interface.correct() rho == alpha1 * rho1 + (1.0 - alpha1) * rho2 pass
def readControls( mesh ): potentialFlow = mesh.solutionDict().subDict( ref.word( "potentialFlow" ) ) nNonOrthCorr = potentialFlow.lookupOrDefault( ref.word( "nNonOrthogonalCorrectors" ), 0 ) return potentialFlow, nNonOrthCorr
def _createFields( runTime, mesh ): ref.ext_Info() << "Reading field p\n" << ref.nl p = man.volScalarField( man.IOobject( ref.word( "p" ), ref.fileName( runTime.timeName() ), mesh, ref.IOobject.MUST_READ, ref.IOobject.AUTO_WRITE ), mesh ) ref.ext_Info() << "Reading field U\n" << ref.nl U = man.volVectorField( man.IOobject( ref.word( "U" ), ref.fileName( runTime.timeName() ), mesh, ref.IOobject.MUST_READ, ref.IOobject.AUTO_WRITE ), mesh ) phi = man.createPhi( runTime, mesh, U ) fluid = man.singlePhaseTransportModel( U, phi ) pRefCell = 0 pRefValue = 0.0 pRefCell, pRefValue = ref.setRefCell( p, mesh.solutionDict().subDict( ref.word( "PISO" ) ), pRefCell, pRefValue ) return p, U, phi, fluid, pRefCell, pRefValue
def updateCoeffs(self): try: if self.updated(): return phip = ref.surfaceScalarField.ext_lookupPatchField( self.patch(), ref.word("phi")) phiap = ref.surfaceScalarField.ext_lookupPatchField( self.patch(), ref.word("phia")) Up = ref.volVectorField.ext_lookupPatchField( self.patch(), ref.word("U")) Uap = ref.volVectorField.ext_lookupPatchField( self.patch(), ref.word("Ua")) self == ((phiap / self.patch().magSf() - 1.0) * phip / self.patch().magSf() + (Up & Uap)) fixedValueFvPatchScalarField.updateCoeffs(self) pass except Exception, exc: import sys, traceback traceback.print_exc(file=sys.stdout) raise exc
def _createFields(runTime, mesh, potentialFlow): ref.ext_Info() << "Reading field p\n" << ref.nl p = man.volScalarField( man.IOobject( ref.word("p"), ref.fileName(runTime.timeName()), mesh, ref.IOobject.MUST_READ, ref.IOobject.NO_WRITE ), mesh, ) p << ref.dimensionedScalar(ref.word("zero"), p.dimensions(), 0.0) ref.ext_Info() << "Reading field U\n" << ref.nl U = man.volVectorField( man.IOobject( ref.word("U"), ref.fileName(runTime.timeName()), mesh, ref.IOobject.MUST_READ, ref.IOobject.AUTO_WRITE ), mesh, ) U << ref.dimensionedVector(ref.word("0"), U.dimensions(), ref.vector.zero) phi = man.surfaceScalarField( man.IOobject( ref.word("phi"), ref.fileName(runTime.timeName()), mesh, ref.IOobject.NO_READ, ref.IOobject.AUTO_WRITE ), man.fvc.interpolate(U) & man.surfaceVectorField(mesh.Sf(), man.Deps(mesh)), ) pRefCell = 0 pRefValue = 0.0 pRefCell, pRefValue = ref.setRefCell(p, potentialFlow, pRefCell, pRefValue) return p, U, phi, pRefCell, pRefValue
def makeGraphs( runTime, mesh, U, turbulence, faceId, patchId, nWallFaces, wallNormal, cellId, flowDirection, y ): R = ref.volSymmTensorField( ref.IOobject( ref.word( "R" ), ref.fileName( runTime.timeName() ), mesh(), ref.IOobject.NO_READ, ref.IOobject.AUTO_WRITE ), turbulence.R() ) runTime.write() gFormat = runTime.graphFormat() ref.makeGraph( y, flowDirection & U(), ref.word( "Uf" ), gFormat ) ref.makeGraph( y, turbulence.ext_nu(), gFormat ) ref.makeGraph( y, turbulence.ext_k(), gFormat ) ref.makeGraph( y, turbulence.ext_epsilon(), gFormat ) ref.makeGraph( y, flowDirection & R & flowDirection, ref.word( "Rff" ), gFormat ) ref.makeGraph( y, wallNormal & R & wallNormal, ref.word( "Rww" ), gFormat ) ref.makeGraph( y, flowDirection & R & wallNormal, ref.word( "Rfw" ), gFormat ) ref.makeGraph( y, R.component( ref.symmTensor.XX ).mag().sqrt(), ref.word( "u" ), gFormat ) ref.makeGraph( y, R.component( ref.symmTensor.YY ).mag().sqrt(), ref.word( "v" ), gFormat ) ref.makeGraph( y, R.component( ref.symmTensor.ZZ ).mag().sqrt(), ref.word( "w" ), gFormat ) ref.makeGraph( y, R.component( ref.symmTensor.XY ), ref.word( "uv" ), gFormat ) ref.makeGraph( y, ref.fvc.grad( U ).mag(), ref.word( "gammaDot" ), gFormat ) pass
def solveFluid( i, mesh, thermo, rad, thermoFluid, rho, K, U, phi, h, turb, DpDt, p, psi, initialMass, p_rgh, gh, ghf,\ oCorr, nCorr, nOuterCorr, nNonOrthCorr, momentumPredictor,cumulativeContErr, finalIter ) : if finalIter: mesh.add(ref.word("finalIteration"), True) pass if oCorr == 0: ref.rhoEqn(rho, phi) pass UEqn = fun_UEqn(rho, U, phi, ghf, p_rgh, turb, mesh, momentumPredictor, finalIter) fun_hEqn(rho, h, phi, turb, DpDt, thermo, rad, mesh, oCorr, nOuterCorr, finalIter) # --- PISO loop for corr in range(nCorr): cumulativeContErr = 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) pass turb.correct() rho << thermo.rho() if finalIter: mesh.remove(ref.word("finalIteration")) pass return cumulativeContErr
def readGravitationalAcceleration(runTime, mesh): ref.ext_Info() << "\nReading gravitationalProperties" << ref.nl gravitationalProperties = man.IOdictionary( man.IOobject( ref.word("gravitationalProperties"), ref.fileName(runTime.constant()), mesh, ref.IOobject.MUST_READ_IF_MODIFIED, ref.IOobject.NO_WRITE, ) ) g = ref.dimensionedVector(gravitationalProperties.lookup(ref.word("g"))) rotating = ref.Switch(gravitationalProperties.lookup(ref.word("rotating"))) if rotating: Omega = ref.dimensionedVector(gravitationalProperties.lookup(ref.word("Omega"))) else: Omega = ref.dimensionedVector(ref.word("Omega"), -ref.dimTime, ref.vector(0, 0, 0)) magg = g.mag() gHat = g / magg return gravitationalProperties, g, rotating, Omega, magg, gHat
def createFields( runTime, mesh ): ref.ext_Info() << "Reading transportProperties\n" transportProperties = man.IOdictionary( man.IOobject( ref.word( "transportProperties" ), ref.fileName( runTime.constant() ), mesh, ref.IOobject.MUST_READ_IF_MODIFIED, ref.IOobject.NO_WRITE ) ) nu = ref.dimensionedScalar( transportProperties.lookup( ref.word( "nu" ) ) ) ref.ext_Info() << "Reading field p\n" << ref.nl p = man.volScalarField( man.IOobject( ref.word( "p" ), ref.fileName( runTime.timeName() ), mesh, ref.IOobject.MUST_READ, ref.IOobject.AUTO_WRITE ), mesh ); ref.ext_Info() << "Reading field U\n" << ref.nl U = man.volVectorField( man.IOobject( ref.word( "U" ), ref.fileName( runTime.timeName() ), mesh, ref.IOobject.MUST_READ, ref.IOobject.AUTO_WRITE ), mesh ); phi = man.createPhi( runTime, mesh, U ) pRefCell = 0 pRefValue = 0.0 pRefCell, pRefValue = ref.setRefCell( p, mesh.solutionDict().subDict( ref.word( "PISO" ) ), pRefCell, pRefValue ) return transportProperties, nu, p, U, phi, pRefCell, pRefValue
def _createFields(runTime, mesh): ref.ext_Info() << "Reading field T\n" << ref.nl T = man.volScalarField( man.IOobject(ref.word("T"), ref.fileName(runTime.timeName()), mesh, ref.IOobject.MUST_READ, ref.IOobject.AUTO_WRITE), mesh) ref.ext_Info() << "Reading field U\n" << ref.nl U = man.volVectorField( man.IOobject(ref.word("U"), ref.fileName(runTime.timeName()), mesh, ref.IOobject.MUST_READ, ref.IOobject.AUTO_WRITE), mesh) ref.ext_Info() << "Reading transportProperties\n" << ref.nl transportProperties = man.IOdictionary( man.IOobject(ref.word("transportProperties"), ref.fileName(runTime.constant()), mesh, ref.IOobject.MUST_READ_IF_MODIFIED, ref.IOobject.NO_WRITE)) ref.ext_Info() << "Reading diffusivity D\n" << ref.nl DT = ref.dimensionedScalar(transportProperties.lookup(ref.word("DT"))) phi = man.createPhi(runTime, mesh, U) return T, U, transportProperties, DT, phi
def _createFields(runTime, mesh): ref.ext_Info() << "Reading field p\n" << ref.nl p = man.volScalarField( man.IOobject( ref.word("p"), ref.fileName(runTime.timeName()), mesh, ref.IOobject.MUST_READ, ref.IOobject.AUTO_WRITE ), mesh, ) ref.ext_Info() << "Reading field U\n" << ref.nl U = man.volVectorField( man.IOobject( ref.word("U"), ref.fileName(runTime.timeName()), mesh, ref.IOobject.MUST_READ, ref.IOobject.AUTO_WRITE ), mesh, ) phi = man.createPhi(runTime, mesh, U) pRefCell = 0 pRefValue = 0.0 pRefCell, pRefValue = ref.setRefCell(p, mesh.solutionDict().subDict(ref.word("PISO")), pRefCell, pRefValue) laminarTransport = man.singlePhaseTransportModel(U, phi) turbulence = man.incompressible.turbulenceModel.New(U, phi, laminarTransport) return p, U, phi, turbulence, pRefCell, pRefValue, laminarTransport
def alphaEqnSubCycle(runTime, pimple, mesh, phi, alpha1, rho, rhoPhi, rho1, rho2, interface): nAlphaCorr = ref.readLabel(pimple.dict().lookup(ref.word("nAlphaCorr"))) nAlphaSubCycles = ref.readLabel(pimple.dict().lookup( ref.word("nAlphaSubCycles"))) if (nAlphaSubCycles > 1): totalDeltaT = runTime.deltaT() rhoPhiSum = 0.0 * rhoPhi alphaSubCycle = ref.subCycle_volScalarField(alpha1, nAlphaSubCycles) for item in alphaSubCycle: alphaEqn(mesh, phi, alpha1, rhoPhi, rho1, rho2, interface, nAlphaCorr) 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 << rhoPhiSum else: alphaEqn(mesh, phi, alpha1, rhoPhi, rho1, rho2, interface, nAlphaCorr) pass interface.correct() rho == alpha1 * rho1 + (1.0 - alpha1) * rho2 pass
def _createFields(runTime, mesh): ref.ext_Info() << "Reading field p\n" << ref.nl p = man.volScalarField( man.IOobject(ref.word("p"), ref.fileName(runTime.timeName()), mesh, ref.IOobject.MUST_READ, ref.IOobject.AUTO_WRITE), mesh) ref.ext_Info() << "Reading field U\n" << ref.nl U = man.volVectorField( man.IOobject(ref.word("U"), ref.fileName(runTime.timeName()), mesh, ref.IOobject.MUST_READ, ref.IOobject.AUTO_WRITE), mesh) phi = man.createPhi(runTime, mesh, U) pRefCell = 0 pRefValue = 0.0 pRefCell, pRefValue = ref.setRefCell( p, mesh.solutionDict().subDict(ref.word("PIMPLE")), pRefCell, pRefValue) laminarTransport = man.singlePhaseTransportModel(U, phi) turbulence = man.incompressible.turbulenceModel.New( U, phi, laminarTransport) ref.ext_Info() << "Reading field rAU if present\n" << ref.nl rAU = man.volScalarField( man.IOobject(ref.word("rAU"), ref.fileName(runTime.timeName()), mesh, ref.IOobject.READ_IF_PRESENT, ref.IOobject.AUTO_WRITE), mesh, runTime.deltaT(), ref.zeroGradientFvPatchScalarField.typeName) sources = man.IObasicSourceList(mesh) return p, U, phi, laminarTransport, turbulence, rAU, pRefCell, pRefValue, sources
def _createFields( runTime, mesh ): ref.ext_Info() << "Reading field T\n" << ref.nl T = man.volScalarField( man.IOobject( ref.word( "T" ), ref.fileName( runTime.timeName() ), mesh, ref.IOobject.MUST_READ, ref.IOobject.AUTO_WRITE ), mesh ) ref.ext_Info() << "Reading field U\n" << ref.nl U = man.volVectorField( man.IOobject( ref.word( "U" ), ref.fileName( runTime.timeName() ), mesh, ref.IOobject.MUST_READ, ref.IOobject.AUTO_WRITE ), mesh ) ref.ext_Info() << "Reading transportProperties\n" << ref.nl transportProperties = man.IOdictionary( man.IOobject( ref.word( "transportProperties" ), ref.fileName( runTime.constant() ), mesh, ref.IOobject.MUST_READ_IF_MODIFIED, ref.IOobject.NO_WRITE ) ) ref.ext_Info() << "Reading diffusivity D\n" << ref.nl DT = ref.dimensionedScalar( transportProperties.lookup( ref.word( "DT" ) ) ) phi = man.createPhi( runTime, mesh, U ) return T, U, transportProperties, DT, phi
def createFields(runTime, mesh): ref.ext_Info() << "Reading thermophysical properties\n" << ref.nl pThermo = man.basicPsiThermo.New(mesh) p = man.volScalarField(pThermo.p(), man.Deps(pThermo)) e = man.volScalarField(pThermo.e(), man.Deps(pThermo)) psi = man.volScalarField(pThermo.psi(), man.Deps(pThermo)) rho = man.volScalarField( man.IOobject(ref.word("rho"), ref.fileName(runTime.timeName()), mesh), man.volScalarField(pThermo.rho(), man.Deps(pThermo))) ref.ext_Info() << "Reading field U\n" << ref.nl U = man.volVectorField( man.IOobject(ref.word("U"), ref.fileName(runTime.timeName()), mesh, ref.IOobject.MUST_READ, ref.IOobject.AUTO_WRITE), mesh) phi = man.compressibleCreatePhi(runTime, mesh, rho, U) ref.ext_Info() << "Creating turbulence model\n" << ref.nl turbulence = man.compressible.turbulenceModel.New(rho, U, phi, pThermo) return pThermo, p, e, psi, rho, U, phi, turbulence
def _createFields(runTime, mesh): ref.ext_Info() << "Reading field p\n" << ref.nl p = man.volScalarField( man.IOobject(ref.word("p"), ref.fileName(runTime.timeName()), mesh, ref.IOobject.MUST_READ, ref.IOobject.AUTO_WRITE), mesh) ref.ext_Info() << "Reading field U\n" << ref.nl U = man.volVectorField( man.IOobject(ref.word("U"), ref.fileName(runTime.timeName()), mesh, ref.IOobject.MUST_READ, ref.IOobject.AUTO_WRITE), mesh) phi = man.createPhi(runTime, mesh, U) pRefCell = 0 pRefValue = 0.0 pRefCell, pRefValue = ref.setRefCell( p, mesh.solutionDict().subDict(ref.word("PIMPLE")), pRefCell, pRefValue) laminarTransport = man.singlePhaseTransportModel(U, phi) turbulence = man.incompressible.turbulenceModel.New( U, phi, laminarTransport) return p, U, phi, turbulence, pRefCell, pRefValue, laminarTransport
def write( runTime, mesh, T ): if runTime.outputTime(): gradT = ref.fvc.grad(T) gradTx = ref.volScalarField( ref.IOobject( ref.word( "gradTx" ), ref.fileName( runTime.timeName() ), mesh, ref.IOobject.NO_READ, ref.IOobject.AUTO_WRITE ), gradT.component( ref.vector.X ) ) gradTy = ref.volScalarField( ref.IOobject( ref.word( "gradTy" ), ref.fileName( runTime.timeName() ), mesh, ref.IOobject.NO_READ, ref.IOobject.AUTO_WRITE ), gradT.component( ref.vector.Y ) ) gradTz = ref.volScalarField( ref.IOobject( ref.word( "gradTz" ), ref.fileName( runTime.timeName() ), mesh, ref.IOobject.NO_READ, ref.IOobject.AUTO_WRITE ), gradT.component( ref.vector.Z ) ) runTime.write() pass
def fun_pEqn( mesh, runTime, pimple, thermo, rho, p, h, psi, U, phi, mrfZones, turbulence, UEqn, DpDt, cumulativeContErr, corr, rhoMax, rhoMin ): rho << thermo.rho() rho << rho().ext_max( rhoMin ) rho << rho().ext_min( rhoMax ) rho.relax() rAU = 1.0 / UEqn.A() U << rAU() * UEqn.H() if pimple.transonic(): phid = ref.surfaceScalarField( ref.word( "phid" ), ref.fvc.interpolate( psi ) * ( ( ref.fvc.interpolate( U ) & mesh.Sf() ) \ + ref.fvc.ddtPhiCorr( rAU, rho, U, phi ) ) ); mrfZones.relativeFlux( ref.fvc.interpolate( psi ), phid ) for nonOrth in range( pimple.nNonOrthCorr() + 1 ): pEqn = ref.fvm.ddt( psi, p) + ref.fvm.div( phid, p ) - ref.fvm.laplacian( rho() * rAU, p ) # mixed calculations pEqn.solve( mesh.solver( p.select( pimple.finalInnerIter( corr, nonOrth ) ) ) ) if nonOrth == pimple.nNonOrthCorr(): phi == pEqn.flux() pass pass pass else: phi << ref.fvc.interpolate( rho ) * ( ( ref.fvc.interpolate( U ) & mesh.Sf() ) + ref.fvc.ddtPhiCorr( rAU, rho, U, phi ) ) mrfZones.relativeFlux( ref.fvc.interpolate( rho ), phi ) for nonOrth in range( pimple.nNonOrthCorr() + 1 ): pEqn = ref.fvm.ddt( psi, p ) + ref.fvc.div( phi ) - ref.fvm.laplacian( rho()*rAU, p ) # mixed calculations pEqn.solve( mesh.solver( p.select( pimple.finalInnerIter( corr, nonOrth ) ) ) ) if nonOrth == pimple.nNonOrthCorr(): phi += pEqn.flux() pass pass pass ref.rhoEqn( rho, phi ) cumulativeContErr = ref.compressibleContinuityErrs( rho(), thermo, cumulativeContErr ) # mixed calculations # Explicitly relax pressure for momentum corrector p.relax() # Recalculate density from the relaxed pressure rho << thermo.rho() rho << rho().ext_max( rhoMin ) rho << rho().ext_min( rhoMax ) rho.relax() ref.ext_Info()<< "rho max/min : " << rho.ext_max().value() << " " << rho.ext_min().value() << ref.nl U -= rAU * ref.fvc.grad( p ) U.correctBoundaryConditions() DpDt << ref.fvc.DDt( ref.surfaceScalarField( ref.word( "phiU" ), phi() / ref.fvc.interpolate( rho ) ), p ) # mixed calculations return cumulativeContErr
def fun_pEqn(mesh, runTime, pimple, thermo, rho, p, h, psi, U, phi, turbulence, gh, ghf, p_rgh, UEqn, DpDt, cumulativeContErr, corr): rho << thermo.rho() # Thermodynamic density needs to be updated by psi*d(p) after the # pressure solution - done in 2 parts. Part 1: thermo.rho() << thermo.rho() - psi() * p_rgh() # mixed calculations rAU = 1.0 / UEqn.A() rhorAUf = ref.surfaceScalarField(ref.word("(rho*(1|A(U)))"), ref.fvc.interpolate(rho * rAU)) U << rAU * UEqn.H() phi << ref.fvc.interpolate(rho) * ((ref.fvc.interpolate(U) & mesh.Sf()) + ref.fvc.ddtPhiCorr(rAU, rho, U, phi)) buoyancyPhi = -rhorAUf * ghf * ref.fvc.snGrad(rho) * mesh.magSf() phi += buoyancyPhi p_rghDDtEqn = ref.fvc.ddt(rho) + psi * ref.correction( ref.fvm.ddt(p_rgh)) + ref.fvc.div(phi) for nonOrth in range(pimple.nNonOrthCorr() + 1): p_rghEqn = p_rghDDtEqn - ref.fvm.laplacian(rhorAUf, p_rgh) p_rghEqn.solve( mesh.solver(p_rgh.select(pimple.finalInnerIter(corr, nonOrth)))) if nonOrth == pimple.nNonOrthCorr(): # Calculate the conservative fluxes 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 += rAU * ref.fvc.reconstruct( (buoyancyPhi + p_rghEqn.flux()) / rhorAUf) U.correctBoundaryConditions() pass pass p << p_rgh + rho * gh # Second part of thermodynamic density update thermo.rho() << thermo.rho() + psi() * p_rgh # mixed calculations DpDt << ref.fvc.DDt( ref.surfaceScalarField(ref.word("phiU"), phi() / ref.fvc.interpolate(rho)), p) # mixed calculations ref.rhoEqn(rho, phi) cumulativeContErr = ref.compressibleContinuityErrs( rho(), thermo, cumulativeContErr) #mixed calculations return cumulativeContErr
def readTimeControls_020000( runTime ): adjustTimeStep = runTime.controlDict().lookupOrDefault( ref.word( "adjustTimeStep" ), ref.Switch( False ) ) maxCo = runTime.controlDict().lookupOrDefault( ref.word( "maxCo" ), 1.0 ) maxDeltaT = runTime.controlDict().lookupOrDefault( ref.word( "maxDeltaT" ), ref.GREAT ) return adjustTimeStep, maxCo, maxDeltaT
def readControls(mesh): potentialFlow = mesh.solutionDict().subDict(ref.word("potentialFlow")) nNonOrthCorr = potentialFlow.lookupOrDefault( ref.word("nNonOrthogonalCorrectors"), 0) return potentialFlow, nNonOrthCorr
def readPIMPLEControls( runTime ): solutionDict = ref.fvSolution( runTime ) pimple = solutionDict.subDict( ref.word( "PIMPLE" ) ) nOuterCorr = pimple.lookupOrDefault( ref.word( "nOuterCorrectors" ), 1); return nOuterCorr
def readFluidMultiRegionPIMPLEControls( mesh ) : pimple = mesh.solutionDict().subDict( ref.word( "PIMPLE" ) ) nCorr = pimple.lookupOrDefault( ref.word( "nCorrectors" ), 1); nNonOrthCorr = pimple.lookupOrDefault( ref.word( "nNonOrthogonalCorrectors" ), 0 ) momentumPredictor =pimple.lookupOrDefault( ref.word( "momentumPredictor" ), ref.Switch( True ) ) return pimple, nCorr, nNonOrthCorr, momentumPredictor
def readPIMPLEControls(runTime): solutionDict = ref.fvSolution(runTime) pimple = solutionDict.subDict(ref.word("PIMPLE")) nOuterCorr = pimple.lookupOrDefault(ref.word("nOuterCorrectors"), 1) return nOuterCorr
def readFluidMultiRegionSIMPLEControls( mesh ) : simple = mesh.solutionDict().subDict( ref.word( "SIMPLE" ) ) nNonOrthCorr = simple.lookupOrDefault( ref.word( "nNonOrthogonalCorrectors" ), 0 ) momentumPredictor = simple.lookupOrDefault( ref.word( "momentumPredictor" ), ref.Switch( True ) ) transonic = simple.lookupOrDefault( ref.word( "transonic" ), ref.Switch( False ) ) return simple, nNonOrthCorr, momentumPredictor, transonic
def readControls(runTime, mesh, pimple): adjustTimeStep, maxCo, maxDeltaT = ref.readTimeControls(runTime) correctPhi = pimple.dict().lookupOrDefault(ref.word("correctPhi"), ref.Switch(True)) checkMeshCourantNo = pimple.dict().lookupOrDefault(ref.word("checkMeshCourantNo"), ref.Switch(False)) return adjustTimeStep, maxCo, maxDeltaT, correctPhi, checkMeshCourantNo
def main_standalone( argc, argv ): ref.argList.addBoolOption( ref.word( "writep" ), "write the final pressure field" ) ref.argList.addBoolOption( ref.word( "initialiseUBCs" ), "initialise U boundary conditions" ) args = ref.setRootCase( argc, argv ) runTime = man.createTime( args ) mesh = man.createMesh( runTime ) potentialFlow, nNonOrthCorr = readControls( mesh ) p, U, phi, pRefCell, pRefValue = _createFields( runTime, mesh, potentialFlow,args ) ref.ext_Info() << ref.nl << "Calculating potential flow" << ref.nl # Since solver contains no time loop it would never execute # function objects so do it ourselves. runTime.functionObjects().start() ref.adjustPhi(phi, U, p) for nonOrth in range( nNonOrthCorr + 1): pEqn = ( ref.fvm.laplacian( ref.dimensionedScalar( ref.word( "1" ), ref.dimTime / p.dimensions() * ref.dimensionSet( 0.0, 2.0, -2.0, 0.0, 0.0 ), 1.0 ), p ) == ref.fvc.div( phi ) ) pEqn.setReference( pRefCell, pRefValue ) pEqn.solve() if nonOrth == nNonOrthCorr: phi -= pEqn.flux() pass pass ref.ext_Info() << "continuity error = " << ref.fvc.div( phi ).mag().weightedAverage( mesh.V() ).value() << ref.nl U << ref.fvc.reconstruct( phi ) U.correctBoundaryConditions() ref.ext_Info() << "Interpolated U error = " << ( ( ( ref.fvc.interpolate( U ) & mesh.Sf() ) - phi ).sqr().sum().sqrt() /mesh.magSf().sum() ).value() << ref.nl # Force the write U.write() phi.write() if args.optionFound( ref.word( "writep" ) ): p.write() pass runTime.functionObjects().end() ref.ext_Info() << "ExecutionTime = " << runTime.elapsedCpuTime() << " s" << \ " ClockTime = " << runTime.elapsedClockTime() << " s" << ref.nl << ref.nl ref.ext_Info() << "End\n" << ref.nl import os return os.EX_OK
def createITstream(pyList): size = len(pyList) ret = ref.tokenList(size) for i in xrange(size): ret[i] = ref.token(ref.word(pyList[i])) pass stream = ref.ITstream( ref.word( "dummy"), ret ) return stream
def createFvMesh(runTime): # Read temporary mesh from file - done only so we can get the list of points, faces and cells tmpMesh = man.fvMesh( man.IOobject( ref.word("tmp"), runTime.caseConstant(), runTime, ref.IOobject.NO_READ, ref.IOobject.NO_WRITE ) ) # Get points, faces & Cells - SFOAM implementation should populate these lists from Salome mesh points = tmpMesh.points() faces = tmpMesh.faces() cells = tmpMesh.cells() # Now create the mesh - Nothing read from file, although fvSchemes and fvSolution created above must be present # It is necessary to store tmpMesh, because fvMesh::points(), faces(), and cells() return const T& # and fvMesh in next line will be broken, after exiting from this function (tmpMesh are deleted) mesh = man.fvMesh( ref.fvMesh( ref.IOobject( ref.word("region0"), runTime.caseConstant(), runTime, ref.IOobject.MUST_READ, ref.IOobject.AUTO_WRITE), points, faces, cells ), man.Deps( tmpMesh ) ) # Create boundary patches patches = ref.polyPatchListPtr( 4, ref.polyPatch.nullPtr() ) patches.set(0, ref.polyPatch.New( ref.word("patch"), ref.word("inlet_F"), 606, 102308, 0, mesh.boundaryMesh() ) ) patches.set(1, ref.polyPatch.New( ref.word("patch"), ref.word("outlet_F1"), 818, 102914, 1, mesh.boundaryMesh() ) ) patches.set(2, ref.polyPatch.New( ref.word("patch"), ref.word("outlet_F2"), 522, 103732, 2, mesh.boundaryMesh() ) ) patches.set(3, ref.polyPatch.New( ref.word("wall"), ref.word("pipe"), 5842, 104254, 3, mesh.boundaryMesh() ) ) mesh.addFvPatches(patches) return mesh, patches
def readTimeControls_020000(runTime): adjustTimeStep = runTime.controlDict().lookupOrDefault( ref.word("adjustTimeStep"), ref.Switch(False)) maxCo = runTime.controlDict().lookupOrDefault(ref.word("maxCo"), 1.0) maxDeltaT = runTime.controlDict().lookupOrDefault(ref.word("maxDeltaT"), ref.GREAT) return adjustTimeStep, maxCo, maxDeltaT
def setInitialrDeltaT(runTime, mesh, pimple): maxDeltaT = pimple.dict().lookupOrDefault(ref.word("maxDeltaT"), ref.GREAT) rDeltaT = man.volScalarField( man.IOobject(ref.word("rDeltaT"), ref.fileName(runTime.timeName()), mesh, ref.IOobject.NO_READ, ref.IOobject.AUTO_WRITE), mesh, 1.0 / ref.dimensionedScalar(ref.word("maxDeltaT"), ref.dimTime, maxDeltaT), ref.zeroGradientFvPatchScalarField.typeName) return maxDeltaT, rDeltaT
def setInitialrDeltaT ( runTime, mesh, pimple ): maxDeltaT = pimple.dict().lookupOrDefault( ref.word( "maxDeltaT" ), ref.GREAT ); rDeltaT = man.volScalarField( man.IOobject( ref.word( "rDeltaT" ), ref.fileName( runTime.timeName() ), mesh, ref.IOobject.NO_READ, ref.IOobject.AUTO_WRITE ), mesh, 1.0 / ref.dimensionedScalar( ref.word( "maxDeltaT" ), ref.dimTime, maxDeltaT ), ref.zeroGradientFvPatchScalarField.typeName ) return maxDeltaT, rDeltaT
def readTransportProperties( runTime, mesh ): ref.ext_Info() << "Reading transportProperties\n" << ref.nl transportProperties = man.IOdictionary( man.IOobject( ref.word( "transportProperties" ), ref.fileName( runTime.constant() ), mesh, ref.IOobject.MUST_READ_IF_MODIFIED, ref.IOobject.NO_WRITE ) ) nu = ref.dimensionedScalar( transportProperties.lookup( ref.word( "nu" ) ) ) return transportProperties, nu
def readTransportProperties(runTime, mesh): ref.ext_Info() << "Reading transportProperties\n" << ref.nl transportProperties = man.IOdictionary( man.IOobject(ref.word("transportProperties"), ref.fileName(runTime.constant()), mesh, ref.IOobject.MUST_READ_IF_MODIFIED, ref.IOobject.NO_WRITE)) mu = ref.dimensionedScalar(transportProperties.lookup(ref.word("mu"))) return transportProperties, mu
def readControls(runTime, mesh, pimple): adjustTimeStep, maxCo, maxDeltaT = ref.readTimeControls(runTime) pimpleDict = pimple.dict() correctPhi = pimpleDict.lookupOrDefault(ref.word("correctPhi"), ref.Switch(False)) checkMeshCourantNo = pimpleDict.lookupOrDefault( ref.word("checkMeshCourantNo"), ref.Switch(False)) return adjustTimeStep, maxCo, maxDeltaT, pimpleDict, correctPhi, checkMeshCourantNo
def fun_pEqn(mesh, runTime, simple, p, rhok, U, phi, turbulence, gh, ghf, p_rgh, UEqn, pRefCell, pRefValue, cumulativeContErr): rAU = ref.volScalarField(ref.word("rAU"), 1.0 / UEqn.A()) rAUf = ref.surfaceScalarField(ref.word("(1|A(U))"), ref.fvc.interpolate(rAU)) U << rAU * UEqn.H() phi << (ref.fvc.interpolate(U) & mesh.Sf()) ref.adjustPhi(phi, U, p_rgh) buoyancyPhi = rAUf * ghf() * ref.fvc.snGrad(rhok) * mesh.magSf() phi -= buoyancyPhi for nonOrth in range(simple.nNonOrthCorr() + 1): p_rghEqn = ref.fvm.laplacian(rAUf, p_rgh) == ref.fvc.div(phi) p_rghEqn.setReference(pRefCell, ref.getRefCellValue(p_rgh, pRefCell)) p_rghEqn.solve() if nonOrth == simple.nNonOrthCorr(): # Calculate the conservative fluxes 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 -= rAU * ref.fvc.reconstruct( (buoyancyPhi + p_rghEqn.flux()) / rAUf) U.correctBoundaryConditions() pass pass cumulativeContErr = ref.ContinuityErrs(phi, runTime, mesh, cumulativeContErr) p << p_rgh + rhok * gh if p_rgh.needReference(): p += ref.dimensionedScalar( ref.word("p"), p.dimensions(), pRefValue - ref.getRefCellValue(p, pRefCell)) p_rgh << p - rhok * gh pass return cumulativeContErr
def _createFields(runTime, mesh, Omega, gHat): ref.ext_Info() << "Reading field h\n" << ref.nl h = man.volScalarField( man.IOobject( ref.word("h"), ref.fileName(runTime.timeName()), mesh, ref.IOobject.MUST_READ, ref.IOobject.AUTO_WRITE ), mesh, ) ref.ext_Info() << "Reading field h0 if present\n" << ref.nl h0 = man.volScalarField( man.IOobject( ref.word("h0"), ref.fileName(runTime.findInstance(ref.fileName(ref.word("polyMesh")), ref.word("points"))), mesh, ref.IOobject.READ_IF_PRESENT, ), mesh, ref.dimensionedScalar(ref.word("h0"), ref.dimLength, 0.0), ) ref.ext_Info() << "Reading field U\n" << ref.nl U = man.volVectorField( man.IOobject( ref.word("U"), ref.fileName(runTime.timeName()), mesh, ref.IOobject.MUST_READ, ref.IOobject.AUTO_WRITE ), mesh, ) ref.ext_Info() << "Creating field hU\n" << ref.nl hU = man.volVectorField( man.IOobject(ref.word("hU"), ref.fileName(runTime.timeName()), mesh), h * U, U.ext_boundaryField().types() ) ref.ext_Info() << "Creating field hTotal for post processing\n" << ref.nl hTotal = man.volScalarField( man.IOobject( ref.word("hTotal"), ref.fileName(runTime.timeName()), mesh, ref.IOobject.READ_IF_PRESENT, ref.IOobject.AUTO_WRITE, ), h + h0, ) hTotal.write() phi = createPhi(runTime, hU, mesh) ref.ext_Info() << "Creating Coriolis Force" << ref.nl F = ref.dimensionedVector(ref.word("F"), ((2.0 * Omega) & gHat) * gHat) return h, h0, U, hU, hTotal, phi, F
def _createFields( runTime, mesh ): ref.ext_Info() << "Reading field p\n" << ref.nl p = man.volScalarField( man.IOobject( ref.word( "p" ), ref.fileName( runTime.timeName() ), mesh, ref.IOobject.MUST_READ, ref.IOobject.AUTO_WRITE ), mesh ) ref.ext_Info() << "Reading field Urel\n" << ref.nl Urel = man.volVectorField( man.IOobject( ref.word( "Urel" ), ref.fileName( runTime.timeName() ), mesh, ref.IOobject.MUST_READ, ref.IOobject.AUTO_WRITE ), mesh ) ref.ext_Info() << "Reading/calculating face flux field phi\n" << ref.nl phi = man.surfaceScalarField( man.IOobject( ref.word( "phi" ), ref.fileName( runTime.timeName() ), mesh, ref.IOobject.READ_IF_PRESENT, ref.IOobject.AUTO_WRITE ), man.surfaceScalarField( ref.linearInterpolate( Urel ) & mesh.Sf(), man.Deps( mesh, Urel ) ) ) pRefCell = 0 pRefValue = 0.0 pRefCell, pRefValue = ref.setRefCell( p, mesh.solutionDict().subDict( ref.word( "PIMPLE" ) ), pRefCell, pRefValue ) laminarTransport = man.singlePhaseTransportModel( Urel, phi ) turbulence = man.incompressible.turbulenceModel.New( Urel, phi, laminarTransport ) ref.ext_Info() << "Creating SRF model\n" << ref.nl SRF = man.SRF.SRFModel.New( Urel ) sources = man.IObasicSourceList( mesh ) # Create the absolute velocity U = man.volVectorField( man.IOobject( ref.word( "U" ), ref.fileName( runTime.timeName() ), mesh, ref.IOobject.NO_READ, ref.IOobject.AUTO_WRITE ), man.volVectorField( Urel() + SRF.U(), man.Deps( Urel, SRF ) ) ) # mixed calculations return p, U, Urel, SRF, phi, turbulence, pRefCell, pRefValue, laminarTransport, sources
def _createControlDict() : """ Creates controlDict dictionary """ a_controlDict = ref.dictionary() a_controlDict.add( ref.word( "startFrom" ), ref.word( "startTime" ) ) a_controlDict.add( ref.word( "startTime" ), 0.0 ) a_controlDict.add( ref.word( "stopAt" ), ref.word( "endTime" ) ) a_controlDict.add( ref.word( "endTime" ), 0.05 ) a_controlDict.add( ref.word( "deltaT" ), 0.01 ) a_controlDict.add( ref.word( "writeControl" ), ref.word( "timeStep" ) ) a_controlDict.add( ref.word( "writeInterval" ), 5 ) return a_controlDict
def readThermophysicalProperties( runTime, mesh ): ref.ext_Info() << "Reading thermophysicalProperties\n" << ref.nl # Pr defined as a separate constant to enable calculation of k, currently # inaccessible through thermo thermophysicalProperties = man.IOdictionary( man.IOobject( ref.word( "thermophysicalProperties" ), ref.fileName( runTime.constant() ), mesh, ref.IOobject.MUST_READ, ref.IOobject.NO_WRITE ) ) Pr = ref.dimensionedScalar.lookupOrDefault( ref.word( "Pr" ), thermophysicalProperties(), 1.0 ) return thermophysicalProperties, Pr
def readThermophysicalProperties(runTime, mesh): ref.ext_Info() << "Reading thermophysicalProperties\n" << ref.nl # Pr defined as a separate constant to enable calculation of k, currently # inaccessible through thermo thermophysicalProperties = man.IOdictionary( man.IOobject(ref.word("thermophysicalProperties"), ref.fileName(runTime.constant()), mesh, ref.IOobject.MUST_READ, ref.IOobject.NO_WRITE)) Pr = ref.dimensionedScalar.lookupOrDefault(ref.word("Pr"), thermophysicalProperties(), 1.0) return thermophysicalProperties, Pr
def _createFields(runTime, mesh): # Load boundary condition from BCs import rho ref.ext_Info() << "Reading thermophysical properties\n" << ref.nl thermo = man.basicPsiThermo.New(mesh) p = man.volScalarField(thermo.p(), man.Deps(thermo)) e = man.volScalarField(thermo.e(), man.Deps(thermo)) T = man.volScalarField(thermo.T(), man.Deps(thermo)) psi = man.volScalarField(thermo.psi(), man.Deps(thermo)) mu = man.volScalarField(thermo.mu(), man.Deps(thermo)) inviscid = True if mu.internalField().max() > 0.0: inviscid = False pass ref.ext_Info() << "Reading field U\n" << ref.nl U = man.volVectorField( man.IOobject(ref.word("U"), ref.fileName(runTime.timeName()), mesh, ref.IOobject.MUST_READ, ref.IOobject.AUTO_WRITE), mesh) pbf, rhoBoundaryTypes = _rhoBoundaryTypes(p) rho = man.volScalarField( man.IOobject(ref.word("rho"), ref.fileName(runTime.timeName()), mesh, ref.IOobject.NO_READ, ref.IOobject.AUTO_WRITE), man.volScalarField(thermo.rho(), man.Deps(thermo)), rhoBoundaryTypes) rhoU = man.volVectorField( man.IOobject(ref.word("rhoU"), ref.fileName(runTime.timeName()), mesh, ref.IOobject.NO_READ, ref.IOobject.NO_WRITE), rho * U) rhoE = man.volScalarField( man.IOobject(ref.word("rhoE"), ref.fileName(runTime.timeName()), mesh, ref.IOobject.NO_READ, ref.IOobject.NO_WRITE), rho * (e + man.volScalarField(0.5 * U.magSqr(), man.Deps(U)))) pos = man.surfaceScalarField( man.IOobject(ref.word("pos"), ref.fileName(runTime.timeName()), mesh), mesh, ref.dimensionedScalar(ref.word("pos"), ref.dimless, 1.0)) neg = man.surfaceScalarField( man.IOobject(ref.word("neg"), ref.fileName(runTime.timeName()), mesh), mesh, ref.dimensionedScalar(ref.word("neg"), ref.dimless, -1.0)) phi = man.surfaceScalarField( ref.word("phi"), man.surfaceVectorField(mesh.Sf(), man.Deps(mesh)) & man.fvc.interpolate(rhoU)) ref.ext_Info() << "Creating turbulence model\n" << ref.nl turbulence = man.compressible.turbulenceModel.New(rho, U, phi, thermo) return thermo, p, e, T, psi, mu, U, pbf, rhoBoundaryTypes, rho, rhoU, rhoE, pos, neg, inviscid, phi, turbulence
def _createFields(runTime, mesh): ref.ext_Info() << "Reading field p\n" << ref.nl p = man.volScalarField( man.IOobject(ref.word("p"), ref.fileName(runTime.timeName()), mesh, ref.IOobject.MUST_READ, ref.IOobject.AUTO_WRITE), mesh) ref.ext_Info() << "Reading field U\n" << ref.nl U = man.volVectorField( man.IOobject(ref.word("U"), ref.fileName(runTime.timeName()), mesh, ref.IOobject.MUST_READ, ref.IOobject.AUTO_WRITE), mesh) phi = man.createPhi(runTime, mesh, U) return p, U, phi
def readTurbulenceProperties( runTime, mesh, U ): ref.ext_Info() << "Reading turbulenceProperties\n" << ref.nl turbulenceProperties = man.IOdictionary( man.IOobject( ref.word( "turbulenceProperties" ), ref.fileName( runTime.constant() ), mesh, ref.IOobject.MUST_READ_IF_MODIFIED, ref.IOobject.NO_WRITE ) ) force = U / ref.dimensionedScalar( ref.word( "dt" ), ref.dimTime, runTime.deltaTValue() ) K = man.Kmesh( mesh ) forceGen = man.UOprocess( K, runTime.deltaTValue(), turbulenceProperties ) return turbulenceProperties, force, K, forceGen
def alphaEqns(runTime, mesh, rho1, rho2, rhoPhi, phic, dgdt, divU, alpha1, alpha2, phi, interface, nAlphaCorr): alphaScheme = ref.word("div(phi,alpha)") alpharScheme = ref.word("div(phirb,alpha)") phir = phic * interface.nHatf() for gCorr in range(nAlphaCorr): Sp = ref.volScalarField.DimensionedInternalField( ref.IOobject(ref.word("Sp"), ref.fileName(runTime.timeName()), mesh), mesh, ref.dimensionedScalar(ref.word("Sp"), dgdt.dimensions(), 0.0)) Su = ref.volScalarField.DimensionedInternalField( ref.IOobject(ref.word("Su"), ref.fileName(runTime.timeName()), mesh), # Divergence term is handled explicitly to be # consistent with the explicit transport solution divU * alpha1.ext_min(1.0)) 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 phiAlpha1 = ref.fvc.flux(phi, alpha1, alphaScheme) + ref.fvc.flux( -ref.fvc.flux(-phir, alpha2, alpharScheme), alpha1, alpharScheme) ref.MULES.explicitSolve(ref.geometricOneField(), alpha1, phi, phiAlpha1, Sp, Su, 1.0, 0.0) rho1f = ref.fvc.interpolate(rho1) rho2f = ref.fvc.interpolate(rho2) rhoPhi << phiAlpha1 * (rho1f - rho2f) + phi * rho2f alpha2 << 1.0 - 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 readGravitationalAcceleration(runTime, mesh): ref.ext_Info() << "\nReading g" << ref.nl g = ref.uniformDimensionedVectorField( ref.IOobject(ref.word("g"), ref.fileName(runTime.constant()), mesh, ref.IOobject.MUST_READ, ref.IOobject.NO_WRITE)) return g
def readTurbulenceProperties(runTime, mesh, U): ref.ext_Info() << "Reading turbulenceProperties\n" << ref.nl turbulenceProperties = man.IOdictionary( man.IOobject(ref.word("turbulenceProperties"), ref.fileName(runTime.constant()), mesh, ref.IOobject.MUST_READ_IF_MODIFIED, ref.IOobject.NO_WRITE)) force = U / ref.dimensionedScalar(ref.word("dt"), ref.dimTime, runTime.deltaTValue()) K = man.Kmesh(mesh) forceGen = man.UOprocess(K, runTime.deltaTValue(), turbulenceProperties) return turbulenceProperties, force, K, forceGen
def fun_pEqn(mesh, runTime, thermo, rho, p, psi, U, phi, turbulence, UEqn, cumulativeContErr, nNonOrthCorr): rho << thermo.rho() rAU = 1.0 / UEqn.A() U << rAU * UEqn.H() phid = ref.surfaceScalarField( ref.word("phid"), ref.fvc.interpolate(psi) * ((ref.fvc.interpolate(U) & mesh.Sf()) + ref.fvc.ddtPhiCorr(rAU, rho, U, phi))) for nonOrth in range(nNonOrthCorr + 1): pEqn = ref.fvm.ddt(psi, p) + ref.fvm.div(phid, p) - ref.fvm.laplacian( rho * rAU, p) pEqn.solve() pass if nonOrth == nNonOrthCorr: phi << pEqn.flux() pass ref.rhoEqn(rho, phi) cumulativeContErr = ref.compressibleContinuityErrs( rho(), thermo, cumulativeContErr ) #it is necessary to force "mixed calculations" implementation U -= rAU * ref.fvc.grad(p) U.correctBoundaryConditions() return cumulativeContErr
def fun_pEqn( mesh, runTime, simple, thermo, rho, p, h, psi, U, phi, turbulence, \ gh, ghf, p_rgh, UEqn, pRefCell, pRefValue, cumulativeContErr, initialMass): rho << thermo.rho() rho.relax() rAU = 1.0 / UEqn.A() rhorAUf = ref.surfaceScalarField(ref.word("(rho*(1|A(U)))"), ref.fvc.interpolate(rho() * rAU)) U << rAU * UEqn.H() phi << ref.fvc.interpolate(rho) * (ref.fvc.interpolate(U()) & mesh.Sf()) closedVolume = ref.adjustPhi(phi, U, p_rgh) buoyancyPhi = rhorAUf * ghf * ref.fvc.snGrad(rho) * mesh.magSf() phi -= buoyancyPhi while simple.correctNonOrthogonal(): p_rghEqn = (ref.fvm.laplacian(rhorAUf, p_rgh) == ref.fvc.div(phi)) p_rghEqn.setReference(pRefCell, ref.getRefCellValue(p_rgh, pRefCell)) p_rghEqn.solve() if simple.finalNonOrthogonalIter(): # Calculate the conservative fluxes 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 -= rAU * ref.fvc.reconstruct( (buoyancyPhi + p_rghEqn.flux()) / rhorAUf) U.correctBoundaryConditions() pass pass cumulativeContErr = ref.ContinuityErrs(phi, runTime, mesh, cumulativeContErr) p << p_rgh + rho * gh # For closed-volume cases adjust the pressure level # to obey overall mass continuity if closedVolume: p += (initialMass - ref.fvc.domainIntegrate(psi * p)) / ref.fvc.domainIntegrate(psi) p_rgh << p - rho * gh pass rho << thermo.rho() rho.relax() ref.ext_Info() << "rho max/min : " << rho.ext_max().value( ) << " " << rho.ext_min().value() << ref.nl return cumulativeContErr
def _init__fvPatch__DimensionedField_vector_volMesh__dictionary( self, *args): if len(args) != 3: raise AssertionError("len( args ) != 3") argc = 0 try: ref.fvPatch.ext_isinstance(args[argc]) except TypeError: raise AssertionError("args[ argc ].__class__ != fvPatch") p = args[argc] argc += 1 try: ref.DimensionedField_vector_volMesh.ext_isinstance(args[argc]) except TypeError: raise AssertionError( "args[ argc ].__class__ != DimensionedField_vector_volMesh") iF = args[argc] argc += 1 try: ref.dictionary.ext_isinstance(args[argc]) except TypeError: raise AssertionError("args[ argc ].__class__ != dictionary") dict_ = args[argc] argc += 1 fixedValueFvPatchVectorField.__init__(self, p, iF) ref.fvPatchVectorField.__lshift__( self, ref.vectorField(ref.word("value"), dict_, p.size())) return self
def setRegionFluidFields( i, fluidRegions, thermoFluid, rhoFluid, KFluid, UFluid, \ phiFluid, turbulence, DpDtFluid, initialMassFluid, ghFluid, ghfFluid, p_rghFluid, radiation ): mesh = fluidRegions[i] thermo = thermoFluid[i] rho = rhoFluid[i] K = KFluid[i] U = UFluid[i] phi = phiFluid[i] turb = turbulence[i] DpDt = DpDtFluid[i] p = thermo.p() psi = thermo.psi() h = thermo.h() p_rgh = p_rghFluid[i] gh = ghFluid[i] ghf = ghfFluid[i] rad = radiation[i] initialMass = ref.dimensionedScalar(ref.word("massIni"), ref.dimMass, initialMassFluid[i]) return mesh, thermo, rho, K, U, phi, turb, DpDt, p, psi, h, initialMass, p_rgh, gh, ghf, rad
def fun_pEqn(mesh, runTime, simple, U, phi, turbulence, p, UEqn, pRefCell, pRefValue, cumulativeContErr): p.ext_boundaryField().updateCoeffs() rAU = 1.0 / UEqn().A() U << rAU * UEqn().H() phi << (ref.fvc.interpolate(U, ref.word("interpolate(HbyA)")) & mesh.Sf()) ref.adjustPhi(phi, U, p) # Non-orthogonal pressure corrector loop while simple.correctNonOrthogonal(): pEqn = ref.fvm.laplacian(rAU, p) == ref.fvc.div(phi) pEqn.setReference(pRefCell, pRefValue) pEqn.solve() if simple.finalNonOrthogonalIter(): phi -= pEqn.flux() pass pass cumulativeContErr = ref.ContinuityErrs(phi, runTime, mesh, cumulativeContErr) # Explicitly relax pressure for momentum corrector p.relax() # Momentum corrector U -= rAU * ref.fvc.grad(p) U.correctBoundaryConditions() return cumulativeContErr