def _UEqn(mesh, alpha1, U, p, p_rgh, ghf, rho, rhoPhi, turbulence, g, twoPhaseProperties, interface, pimple): muEff = ref.surfaceScalarField( ref.word("muEff"), twoPhaseProperties.muf() + ref.fvc.interpolate(rho * turbulence.ext_nut()) ) UEqn = ( ref.fvm.ddt(rho, U) + ref.fvm.div(rhoPhi, U) - ref.fvm.laplacian(muEff, U) - (ref.fvc.grad(U) & ref.fvc.grad(muEff)) ) UEqn.relax() if pimple.momentumPredictor(): ref.solve( UEqn == ref.fvc.reconstruct( ( ref.fvc.interpolate(interface.sigmaK()) * ref.fvc.snGrad(alpha1) - ghf * ref.fvc.snGrad(rho) - ref.fvc.snGrad(p_rgh) ) * mesh.magSf() ) ) pass return UEqn
def main_standalone(argc, argv): args = ref.setRootCase(argc, argv) runTime = man.createTime(args) mesh = man.createMesh(runTime) T, U, transportProperties, DT, phi = _createFields(runTime, mesh) simple = man.simpleControl(mesh) ref.ext_Info() << "\nCalculating scalar transport\n" << ref.nl CoNum, meanCoNum = ref.CourantNo(mesh, phi, runTime) while simple.loop(): ref.ext_Info() << "Time = " << runTime.timeName() << ref.nl << ref.nl while simple.correctNonOrthogonal(): ref.solve( ref.fvm.ddt(T) + ref.fvm.div(phi, T) - ref.fvm.laplacian(DT, T)) pass runTime.write() pass ref.ext_Info() << "End\n" << ref.nl import os return os.EX_OK
def main_standalone( argc, argv ): args = ref.setRootCase( argc, argv ) runTime = man.createTime( args ) mesh = man.createMesh( runTime ) T, transportProperties, DT = _createFields( runTime, mesh ) simple = man.simpleControl( mesh ) ref.ext_Info() << "\nCalculating temperature distribution\n" << ref.nl while runTime.loop() : ref.ext_Info() << "Time = " << runTime.timeName() << ref.nl << ref.nl for nonOrth in range( simple.nNonOrthCorr() + 1 ): ref.solve( ref.fvm.ddt( T ) - ref.fvm.laplacian( DT, T ) ) pass write( runTime, mesh, T ) ref.ext_Info() << "ExecutionTime = " << runTime.elapsedCpuTime() << " s" << \ " ClockTime = " << runTime.elapsedClockTime() << " s" << ref.nl << ref.nl pass ref.ext_Info() << "End\n" << ref.nl import os return os.EX_OK
def main_standalone(argc, argv): args = ref.setRootCase(argc, argv) runTime = man.createTime(args) mesh = man.createMesh(runTime) T, transportProperties, DT = _createFields(runTime, mesh) simple = man.simpleControl(mesh) ref.ext_Info() << "\nCalculating temperature distribution\n" << ref.nl while runTime.loop(): ref.ext_Info() << "Time = " << runTime.timeName() << ref.nl << ref.nl while simple.correctNonOrthogonal(): ref.solve(ref.fvm.ddt(T) - ref.fvm.laplacian(DT, T)) pass write(runTime, mesh, T) ref.ext_Info() << "ExecutionTime = " << runTime.elapsedCpuTime() << " s" << \ " ClockTime = " << runTime.elapsedClockTime() << " s" << ref.nl << ref.nl pass ref.ext_Info() << "End\n" << ref.nl import os return os.EX_OK
def main_standalone( argc, argv ): args = ref.setRootCase( argc, argv ) runTime = man.createTime( args ) mesh = man.createMesh( runTime ) T, U, transportProperties, DT, phi = _createFields( runTime, mesh ) simple = man.simpleControl( mesh ) ref.ext_Info() << "\nCalculating scalar transport\n" << ref.nl CoNum, meanCoNum = ref.CourantNo( mesh, phi, runTime ) while simple.loop(): ref.ext_Info() << "Time = " << runTime.timeName() << ref.nl << ref.nl for nonOrth in range ( simple.nNonOrthCorr() + 1 ): ref.solve( ref.fvm.ddt( T ) + ref.fvm.div( phi, T ) - ref.fvm.laplacian( DT, T ) ) pass runTime.write() pass ref.ext_Info() << "End\n" << ref.nl import os return os.EX_OK
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 fun_eEqn(rho, e, phi, turbulence, p, thermo): ref.solve( ref.fvm.ddt(rho, e) + ref.fvm.div(phi, e) - ref.fvm.laplacian(turbulence.alphaEff(), e) == -p() * ref.fvc.div(phi() / ref.fvc.interpolate(rho))) # mixed calculation thermo.correct() pass
def _UEqn( phi, U, p, rho, turbulence ): # Solve the Momentum equation UEqn = man.fvVectorMatrix( turbulence.divDevRhoReff( U ), man.Deps( turbulence ) ) + man.fvm.div( phi, U ) UEqn.relax() ref.solve( UEqn == -ref.fvc.grad( p ) ) return UEqn
def fun_UEqn( U, phi, turbulence, p ): # Solve the Momentum equation UEqn = man.fvm.div( phi, U ) + man( turbulence.divDevReff( U ), man.Deps( turbulence, U ) ) UEqn.relax() ref.solve( UEqn == -man.fvc.grad( p ) ) return UEqn
def fun_Ueqn( simple, mesh, rho, U, phi, turbulence, ghf, p_rgh ): UEqn = man.fvm.div( phi, U ) + man( turbulence.divDevRhoReff( U ), man.Deps( turbulence, U) ) UEqn.relax() if simple.momentumPredictor(): ref.solve( UEqn == man.fvc.reconstruct( ( ( - ghf * man.fvc.snGrad( rho ) - man.fvc.snGrad( p_rgh ) ) * man.surfaceScalarField( mesh.magSf(), man.Deps( mesh ) ) ) ) ) return UEqn
def fun_UEqn( mesh, pimple, U, phi, turbulence, p, rhok, p_rgh, ghf ): UEqn = man.fvm.ddt( U ) + man.fvm.div(phi, U) + man( turbulence.divDevReff( U ) , man.Deps( U ) ) UEqn.relax() if pimple.momentumPredictor(): ref.solve( UEqn == man.fvc.reconstruct( ( - ghf * man.fvc.snGrad( rhok ) - man.fvc.snGrad( p_rgh ) ) * man.surfaceScalarField( mesh.magSf(), mesh ) ) ) pass return UEqn
def fun_UEqn( mesh, simple, U, phi, turbulence, p, rhok, p_rgh, ghf ): UEqn = man.fvm.div(phi, U) + man( turbulence.divDevReff( U ) , man.Deps( U ) ) UEqn.relax() if simple.momentumPredictor(): ref.solve( UEqn == man.fvc.reconstruct( ( - ghf * man.fvc.snGrad( rhok ) - man.fvc.snGrad( p_rgh ) ) * man.surfaceScalarField( mesh.magSf(), mesh ) ) ) pass return UEqn
def fun_UEqn( rho, U, phi, ghf, p_rgh, turb, mesh ): # Solve the Momentum equation UEqn = man.fvm.div( phi, U ) + man.fvVectorMatrix( turb.divDevRhoReff( U ), man.Deps( turb, U ) ) UEqn.relax() ref.solve( UEqn() == ref.fvc.reconstruct( ( -ghf * ref.fvc.snGrad( rho ) - ref.fvc.snGrad( p_rgh ) ) * mesh.magSf() ) ) return UEqn
def fun_UEqn(U, phi, turbulence, p): # Solve the Momentum equation UEqn = man.fvm.div(phi, U) + man(turbulence.divDevReff(U), man.Deps(turbulence, U)) UEqn.relax() ref.solve(UEqn == -man.fvc.grad(p)) return UEqn
def fun_pEqn( runTime, mesh, pimple, UEqn, p, p_rgh, phi, U, rho, rho1, rho2, rho10, rho20, gh, ghf, dgdt, pMin, \ psi1, psi2, alpha1, alpha2, interface, corr ): rAU = 1.0 / UEqn.A() rAUf = ref.fvc.interpolate(rAU) p_rghEqnComp = None if pimple.transonic(): p_rghEqnComp = ref.fvm.ddt(p_rgh) + ref.fvm.div( phi, p_rgh) - ref.fvm.Sp(ref.fvc.div(phi), p_rgh) pass else: p_rghEqnComp = ref.fvm.ddt(p_rgh) + ref.fvc.div( phi, p_rgh) - ref.fvc.Sp(ref.fvc.div(phi), p_rgh) pass U << rAU * UEqn.H() phiU = ref.surfaceScalarField(ref.word("phiU"), (ref.fvc.interpolate(U) & mesh.Sf()) + ref.fvc.ddtPhiCorr(rAU, rho, U, phi)) phi << (phiU + (ref.fvc.interpolate(interface.sigmaK()) * ref.fvc.snGrad(alpha1) - ghf * ref.fvc.snGrad(rho)) * rAUf * mesh.magSf()) for nonOrth in range(pimple.nNonOrthCorr() + 1): p_rghEqnIncomp = ref.fvc.div(phi) - ref.fvm.laplacian(rAUf, p_rgh) ref.solve( (alpha1.ext_max(0.0) * (psi1 / rho1) + alpha2.ext_max(0.0) * (psi2 / rho2)) * p_rghEqnComp() + p_rghEqnIncomp, ## mesh.solver(p_rgh.select(pimple.finalInnerIter(corr, nonOrth)))) if nonOrth == pimple.nNonOrthCorr(): dgdt << (alpha2.pos() * (psi2 / rho2) - alpha1.pos() * (psi1 / rho1)) * (p_rghEqnComp & p_rgh) phi += p_rghEqnIncomp.flux() pass U += rAU * ref.fvc.reconstruct((phi() - phiU) / rAUf) # mixed calculations U.correctBoundaryConditions() p << ((p_rgh() + gh * (alpha1() * rho10 + alpha2 * rho20)) / (1.0 - gh * (alpha1() * psi1 + alpha2 * psi2))).ext_max(pMin) # rho1 << rho10 + psi1 * p rho2 << rho20 + psi2 * p ref.ext_Info() << "max(U) " << U.mag().ext_max().value() << ref.nl ref.ext_Info() << "min(p_rgh) " << p_rgh.ext_min().value() << ref.nl pass
def fun_UEqn( U, phi, turbulence, p, sources ): # Solve the Momentum equation UEqn = man.fvm.div( phi, U ) + man( turbulence.divDevReff( U ), man.Deps( turbulence, U ) ) == man( sources( U ), man.Deps( U ) ) UEqn.relax() sources.constrain( UEqn ) ref.solve( UEqn == -man.fvc.grad( p ) ) return UEqn
def fun_Ueqn(pimple, mesh, rho, U, phi, turbulence, ghf, p_rgh): # Solve the Momentum equation UEqn = man.fvm.ddt(rho, U) + man.fvm.div(phi, U) + man.fvVectorMatrix( turbulence.divDevRhoReff(U()), man.Deps(turbulence, U)) UEqn.relax() if pimple.momentumPredictor(): ref.solve(UEqn == man.fvc.reconstruct( (-ghf * man.fvc.snGrad(rho) - man.fvc.snGrad(p_rgh)) * man.surfaceScalarField(mesh.magSf(), man.Deps(mesh)))) return UEqn
def fun_UrelEqn( Urel, phi, turbulence, p, sources, SRF ): # Solve the Momentum equation UrelEqn = man.fvVectorMatrix( ref.fvm.div( phi, Urel ) + turbulence.divDevReff( Urel ) + SRF.Su(), man.Deps( turbulence, Urel, phi, SRF ) ) \ == man( sources( Urel ), man.Deps( Urel ) ) UrelEqn.relax() sources.constrain( UrelEqn ) ref.solve( UrelEqn == -man.fvc.grad( p ) ) return UrelEqn
def fun_UrelEqn(Urel, phi, turbulence, p, sources, SRF): # Solve the Momentum equation UrelEqn = man.fvVectorMatrix( ref.fvm.div( phi, Urel ) + turbulence.divDevReff( Urel ) + SRF.Su(), man.Deps( turbulence, Urel, phi, SRF ) ) \ == man( sources( Urel ), man.Deps( Urel ) ) UrelEqn.relax() sources.constrain(UrelEqn) ref.solve(UrelEqn == -man.fvc.grad(p)) return UrelEqn
def fun_UEqn( rho, U, phi, ghf, p_rgh, turb, mesh, momentumPredictor, finalIter ) : # Solve the Momentum equation UEqn = man.fvm.ddt( rho, U ) + man.fvm.div( phi, U ) + man.fvVectorMatrix( turb.divDevRhoReff( U ), man.Deps( turb, U ) ) UEqn.relax() if momentumPredictor : ref.solve( UEqn() == ref.fvc.reconstruct( ( -ghf * ref.fvc.snGrad( rho ) - ref.fvc.snGrad( p_rgh ) ) * mesh.magSf() ), mesh.solver( U.select( finalIter ) ) ) pass return UEqn
def fun_UEqn(U, phi, turbulence, p, sources): # Solve the Momentum equation UEqn = man.fvm.div(phi, U) + man(turbulence.divDevReff(U), man.Deps(turbulence, U)) == man( sources(U), man.Deps(U)) UEqn.relax() sources.constrain(UEqn) ref.solve(UEqn == -man.fvc.grad(p)) return UEqn
def fun_UEqn( rho, U, K, phi, ghf, p_rgh, turb, mesh, momentumPredictor, finalIter ): # Solve the Momentum equation UEqn = man.fvm.ddt( rho, U ) + man.fvm.div( phi, U ) + man.fvVectorMatrix( turb.divDevRhoReff( U ), man.Deps( turb, U ) ) UEqn.relax() if momentumPredictor : ref.solve( UEqn() == ref.fvc.reconstruct( ( -ghf * ref.fvc.snGrad( rho ) - ref.fvc.snGrad( p_rgh ) ) * mesh.magSf() ), mesh.solver( U.select( finalIter ) ) ) K << 0.5 * U.magSqr() pass return UEqn
def fun_UEqn( mesh, U, p_rgh, ghf, rho, rhoPhi, turbulence, twoPhaseProperties, pimple ): muEff = man.surfaceScalarField( ref.word( "muEff" ), man.surfaceScalarField( twoPhaseProperties.muf(), man.Deps( twoPhaseProperties ) ) + man.fvc.interpolate( rho * man.volScalarField( turbulence.ext_nut(), man.Deps( turbulence ) ) ) ) UEqn = man.fvm.ddt( rho, U ) + man.fvm.div( rhoPhi, U ) - man.fvm.laplacian( muEff, U ) - ( man.fvc.grad( U ) & man.fvc.grad( muEff ) ) UEqn.relax() if pimple.momentumPredictor(): ref.solve( UEqn == ref.fvc.reconstruct( ( - ghf * ref.fvc.snGrad( rho ) - ref.fvc.snGrad( p_rgh ) ) * mesh.magSf() ) ) pass return UEqn
def Ueqn( mesh, pimple, phi, U, p, turbulence, sources ): UEqn = man.fvm.ddt(U) + man.fvm.div(phi, U) + man.fvVectorMatrix( turbulence.divDevReff( U ), man.Deps( turbulence, U ) ) \ == man.fvVectorMatrix( sources(U), man.Deps( U ) ) UEqn.relax() sources.constrain( UEqn ) rAU = man.volScalarField( 1.0/UEqn.A(), man.Deps( UEqn ) ) if pimple.momentumPredictor(): ref.solve( UEqn == -man.fvc.grad( p ) ) pass return UEqn, rAU
def Ueqn( mesh, pimple, phi, U, p, turbulence, sources ): # 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 = man.fvm.ddt(U) + man.fvm.div(phi, U) + man.fvVectorMatrix( turbulence.divDevReff( U ), man.Deps( turbulence, U ) ) UEqn = man.fvVectorMatrix( turbulence.divDevReff( U ), man.Deps( turbulence, U ) ) + ( man.fvm.ddt(U) + man.fvm.div(phi, U) ) UEqn.relax() sources.constrain( UEqn ) rAU = man.volScalarField( 1.0/UEqn.A(), man.Deps( UEqn ) ) if pimple.momentumPredictor(): ref.solve( UEqn == -ref.fvc.grad( p ) + sources( U ) ) pass return UEqn, rAU
def fun_UEqn( mesh, phi, U, p, rAU, turbulence, pimple ): # 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 = man.fvm.ddt(U) + man.fvm.div(phi, U) + man.fvVectorMatrix( turbulence.divDevReff( U ), man.Deps( turbulence, U ) ) UEqn = man.fvVectorMatrix( turbulence.divDevReff( U ), man.Deps( turbulence, U ) ) + ( man.fvm.ddt(U) + man.fvm.div(phi, U) ) UEqn.relax() rAU << 1.0 / UEqn.A() if pimple.momentumPredictor(): ref.solve( UEqn() == -ref.fvc.grad( p ) ) pass return UEqn
def Ueqn( mesh, pimple, phi, U, p, turbulence ): UEqn = man.fvm.ddt(U) + man.fvm.div(phi, U) + man.fvVectorMatrix( turbulence.divDevReff( U ), man.Deps( turbulence, U ) ) UEqn.relax() rAU = man.volScalarField( 1.0/UEqn.A(), man.Deps( UEqn ) ) if pimple.momentumPredictor(): ref.solve( UEqn == -man.fvc.grad( p ) ) pass else: U << rAU * ( UEqn.H() - ref.fvc.grad( p ) ) U.correctBoundaryConditions() pass return UEqn, rAU
def fun_UEqn(mesh, phi, U, p, rAU, turbulence, pimple): # 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 = man.fvm.ddt(U) + man.fvm.div(phi, U) + man.fvVectorMatrix( turbulence.divDevReff( U ), man.Deps( turbulence, U ) ) UEqn = man.fvVectorMatrix(turbulence.divDevReff(U), man.Deps( turbulence, U)) + (man.fvm.ddt(U) + man.fvm.div(phi, U)) UEqn.relax() rAU << 1.0 / UEqn.A() if pimple.momentumPredictor(): ref.solve(UEqn() == -ref.fvc.grad(p)) pass return UEqn
def Ueqn(mesh, pimple, phi, U, p, turbulence, sources): # 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 = man.fvm.ddt(U) + man.fvm.div(phi, U) + man.fvVectorMatrix( turbulence.divDevReff( U ), man.Deps( turbulence, U ) ) UEqn = man.fvVectorMatrix(turbulence.divDevReff(U), man.Deps( turbulence, U)) + (man.fvm.ddt(U) + man.fvm.div(phi, U)) UEqn.relax() sources.constrain(UEqn) rAU = man.volScalarField(1.0 / UEqn.A(), man.Deps(UEqn)) if pimple.momentumPredictor(): ref.solve(UEqn == -ref.fvc.grad(p) + sources(U)) pass return UEqn, rAU
def step(self, nCorr=1, nNonOrthCorr=1): U_ = self.U p_ = self.p phi_ = self.phi runTime_ = self.runTime mesh_ = U_.mesh() runTime_.increment() # Read transport properties nu = ref.dimensionedScalar(self.transportProperties.lookup(ref.word("nu"))) tmp_UEqn = ( ref.fvm.ddt( U_ ) + ref.fvm.div( phi_, U_ ) - ref.fvm.laplacian( nu, U_ ) ) UEqn = tmp_UEqn() self.velocityRes = ref.solve( UEqn == -ref.fvc.grad( p_ ) ).initialResidual() # --- PISO loop for corr in range(nCorr): tmp_rUA = 1.0 / UEqn.A() rUA = tmp_rUA() U_ << rUA * UEqn.H() phi_ << ( ref.fvc.interpolate(U_) & mesh_.Sf() ) for nonOrth in range(nNonOrthCorr): tmp_pEqn = ( ref.fvm.laplacian( rUA, p_ ) == ref.fvc.div( phi_ ) ) pEqn = tmp_pEqn() pEqn.setReference( self.pRefCell, self.pRefValue ) pressureRes = pEqn.solve().initialResidual() if nonOrth == 0: self.pressureRes = pressureRes if nonOrth == nNonOrthCorr: phi_ -= pEqn.flux() # Continuity errors tmp_contErr = ref.fvc.div( phi_ ); contErr = tmp_contErr() sumLocalContErr = ( runTime_.deltaT().value() * contErr.mag().weightedAverage( mesh_.V() ).value() ) globalContErr = ( runTime_.deltaT().value() * contErr.weightedAverage( mesh_.V() ).value() ) print "time step continuity errors : sum local = " + str(sumLocalContErr) + ", global = " + str(globalContErr) # Correct velocity U_-= rUA * ref.fvc.grad( p_ ) U_.correctBoundaryConditions()
def fun_UEqn( mesh, phi, U, p, turbulence, pZones, nUCorr, pressureImplicitPorosity ): # 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 ) + turbulence.divDevReff( U ) UEqn = man.fvVectorMatrix( turbulence.divDevReff( U ), man.Deps( turbulence, U ) ) + man.fvm.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 : 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" ) ) for UCorr in range ( nUCorr ): U << ( trTU() & ( UEqn.H() - ref.fvc.grad( p ) ) ) # mixed calculations pass U.correctBoundaryConditions() pass else: pZones.addResistance( UEqn ) ref.solve( UEqn == -man.fvc.grad( p ) ) trAU = man.volScalarField( 1.0 / UEqn.A(), man.Deps( UEqn ) ) trAU.rename( ref.word( "rAU" ) ) pass return UEqn, trTU, trAU
def Ueqn(mesh, pimple, phi, U, p, turbulence): UEqn = man.fvm.ddt(U) + man.fvm.div(phi, U) + man.fvVectorMatrix( turbulence.divDevReff(U), man.Deps(turbulence, U)) UEqn.relax() rAU = man.volScalarField(1.0 / UEqn.A(), man.Deps(UEqn)) if pimple.momentumPredictor(): ref.solve(UEqn == -man.fvc.grad(p)) pass else: U << rAU * (UEqn.H() - ref.fvc.grad(p)) U.correctBoundaryConditions() pass return UEqn, rAU
def _UrelEqn( mesh, pimple, phi, Urel, p, turbulence, SRF, sources ): # Relative momentum predictor # 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++ # UrelEqn = man.fvVectorMatrix( ref.fvm.ddt( Urel ) + ref.fvm.div( phi, Urel ) + turbulence.divDevReff( Urel ) + SRF.Su(), \ # man.Deps( phi, Urel, turbulence, SRF ) ); UrelEqn = man.fvVectorMatrix( turbulence.divDevReff( Urel ) + ref.fvm.div( phi, Urel ) + ref.fvm.ddt( Urel ) + SRF.Su(), \ man.Deps( phi, Urel, turbulence, SRF ) ); UrelEqn.relax() sources.constrain( UrelEqn ) ref.solve( UrelEqn == -ref.fvc.grad( p ) + sources( Urel ) ) return UrelEqn
def fun_pEqn( runTime, mesh, pimple, UEqn, p, p_rgh, phi, U, rho, rho1, rho2, rho10, rho20, gh, ghf, dgdt, pMin, \ psi1, psi2, alpha1, alpha2, interface ): rAU = 1.0/UEqn.A() rAUf = ref.fvc.interpolate( rAU ) p_rghEqnComp = None if pimple.transonic(): p_rghEqnComp = ref.fvm.ddt( p_rgh ) + ref.fvm.div( phi, p_rgh ) - ref.fvm.Sp( ref.fvc.div( phi ), p_rgh ) pass else: p_rghEqnComp = ref.fvm.ddt( p_rgh ) + ref.fvc.div( phi, p_rgh ) - ref.fvc.Sp( ref.fvc.div( phi ), p_rgh ) pass U << rAU * UEqn.H() phiU = ref.surfaceScalarField( ref.word( "phiU" ), ( ref.fvc.interpolate( U ) & mesh.Sf() ) + ref.fvc.ddtPhiCorr( rAU, rho, U, phi ) ) phi << (phiU + ( ref.fvc.interpolate( interface.sigmaK() ) * ref.fvc.snGrad( alpha1 ) - ghf * ref.fvc.snGrad( rho ) ) * rAUf * mesh.magSf() ) while (pimple.correctNonOrthogonal()): p_rghEqnIncomp = ref.fvc.div( phi ) - ref.fvm.laplacian( rAUf, p_rgh ) ref.solve( ( alpha1.ext_max( 0.0 ) * ( psi1 / rho1 ) + alpha2.ext_max( 0.0 ) * ( psi2 / rho2 ) ) *p_rghEqnComp() + p_rghEqnIncomp, ## mesh.solver( p_rgh.select( pimple.finalInnerIter() ) ) ) if pimple.finalNonOrthogonalIter(): dgdt << ( alpha2.pos() * ( psi2 / rho2 ) - alpha1.pos() * ( psi1 / rho1 ) ) * ( p_rghEqnComp & p_rgh ) phi += p_rghEqnIncomp.flux() pass U += rAU * ref.fvc.reconstruct( ( phi() - phiU ) / rAUf ) # mixed calculations U.correctBoundaryConditions() p << ( ( p_rgh() + gh * ( alpha1() * rho10 + alpha2 * rho20 ) ) /( 1.0 - gh * ( alpha1() * psi1 + alpha2 * psi2 ) ) ).ext_max( pMin ) # rho1 << rho10 + psi1 * p rho2 << rho20 + psi2 * p ref.ext_Info() << "max(U) " << U.mag().ext_max().value() << ref.nl ref.ext_Info() << "min(p_rgh) " << p_rgh.ext_min().value() << ref.nl pass
def fun_UEqn(mesh, alpha1, U, p, p_rgh, ghf, rho, rhoPhi, turbulence, g, twoPhaseProperties, interface, pimple): muEff = ref.surfaceScalarField( ref.word("muEff"), twoPhaseProperties.muf() + ref.fvc.interpolate(rho * turbulence.ext_nut())) UEqn = ref.fvm.ddt(rho, U) + ref.fvm.div(rhoPhi, U) - ref.fvm.laplacian( muEff, U) - (ref.fvc.grad(U) & ref.fvc.grad(muEff)) UEqn.relax() if pimple.momentumPredictor(): ref.solve( UEqn == \ ref.fvc.reconstruct( ( ref.fvc.interpolate( interface.sigmaK() ) * ref.fvc.snGrad( alpha1 ) - ghf * ref.fvc.snGrad( rho ) \ - ref.fvc.snGrad( p_rgh ) ) * mesh.magSf() ) ) pass return UEqn
def fun_Ueqn( pimple, rho, p, U, phi, turbulence, mrfZones, pZones ): # 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 = man.fvm.ddt( rho, U ) + man.fvm.div( phi, U ) + man.fvVectorMatrix( turbulence.divDevRhoReff( U ), man.Deps( turbulence, U ) ) UEqn = man.fvVectorMatrix( turbulence.divDevRhoReff( U ), man.Deps( turbulence, U ) ) + ( man.fvm.div( phi, U ) + man.fvm.ddt( rho, U ) ) UEqn.relax() mrfZones.addCoriolis( rho, UEqn ) pZones.addResistance( UEqn ) rAU = 1.0 / UEqn.A() if pimple.momentumPredictor(): ref.solve( UEqn == -man.fvc.grad( p ) ) pass return UEqn
def fun_Ueqn(pimple, mesh, rho, U, phi, turbulence, ghf, p_rgh): # Solve the Momentum equation UEqn = ( man.fvm.ddt(rho, U) + man.fvm.div(phi, U) + man.fvVectorMatrix(turbulence.divDevRhoReff(U()), man.Deps(turbulence, U)) ) UEqn.relax() if pimple.momentumPredictor(): ref.solve( UEqn == man.fvc.reconstruct( (-ghf * man.fvc.snGrad(rho) - man.fvc.snGrad(p_rgh)) * man.surfaceScalarField(mesh.magSf(), man.Deps(mesh)) ) ) return UEqn
def fun_UEqn( mesh, phi, U, p, turbulence, pZones, nUCorr, pressureImplicitPorosity, sources ): # Construct the Momentum equation UEqn = man.fvm.div( phi, U ) + man.fvVectorMatrix( turbulence.divDevReff( U ), man.Deps( turbulence, U ) ) == man( sources( U ), man.Deps( U ) ) UEqn.relax() sources.constrain( UEqn ) # 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 : 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" ) ) for UCorr in range ( nUCorr ): U << ( trTU() & ( UEqn.H() - ref.fvc.grad( p ) ) ) # mixed calculations pass U.correctBoundaryConditions() pass else: pZones.addResistance( UEqn ) ref.solve( UEqn == -man.fvc.grad( p ) ) trAU = man.volScalarField( 1.0 / UEqn.A(), man.Deps( UEqn ) ) trAU.rename( ref.word( "rAU" ) ) pass return UEqn, trTU, trAU
def fun_Ueqn( pimple, rho, p, U, phi, turbulence ): # 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 = man.fvm.ddt( rho, U ) + man.fvm.div( phi, U ) + man.fvVectorMatrix( turbulence.divDevRhoReff( U ), man.Deps( turbulence, U ) ) UEqn = man.fvVectorMatrix( turbulence.divDevRhoReff( U ), man.Deps( turbulence, U ) ) + ( man.fvm.div( phi, U ) + man.fvm.ddt( rho, U ) ) UEqn.relax() rAU = 1.0 / UEqn.A() if pimple.momentumPredictor(): ref.solve( UEqn == -man.fvc.grad( p ) ) pass else: U << rAU * ( UEqn.H() - ref.fvc.grad( p ) ) U.correctBoundaryConditions() pass return UEqn, rAU
def fun_Ueqn(pimple, rho, p, U, phi, turbulence, mrfZones, pZones): # 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 = man.fvm.ddt( rho, U ) + man.fvm.div( phi, U ) + man.fvVectorMatrix( turbulence.divDevRhoReff( U ), man.Deps( turbulence, U ) ) UEqn = man.fvVectorMatrix( turbulence.divDevRhoReff(U), man.Deps( turbulence, U)) + (man.fvm.div(phi, U) + man.fvm.ddt(rho, U)) UEqn.relax() mrfZones.addCoriolis(rho, UEqn) pZones.addResistance(UEqn) rAU = 1.0 / UEqn.A() if pimple.momentumPredictor(): ref.solve(UEqn == -man.fvc.grad(p)) pass return UEqn
def main_standalone( argc, argv ): args = ref.setRootCase( argc, argv ) runTime = man.createTime( args ) mesh = man.createMeshNoClear( runTime ) p, U, phi, fluid, pRefCell, pRefValue = _createFields( runTime, mesh ) cumulativeContErr = ref.initContinuityErrs() ref.ext_Info() << "\nStarting time loop\n" << ref.nl while runTime.loop() : ref.ext_Info() << "Time = " << runTime.timeName() << ref.nl << ref.nl piso, nCorr, nNonOrthCorr, momentumPredictor, transonic, nOuterCorr = ref.readPISOControls( mesh ) CoNum, meanCoNum = ref.CourantNo( mesh, phi, runTime ) fluid.correct() UEqn = ref.fvm.ddt( U ) + ref.fvm.div( phi, U ) - ref.fvm.laplacian( fluid.ext_nu(), U ) - ( ref.fvc.grad( U ) & ref.fvc.grad( fluid.ext_nu() ) ) ref.solve( UEqn == -ref.fvc.grad( p ) ) # --- PISO loop for corr in range( nCorr ): rAU = 1.0 / UEqn.A() U << rAU * UEqn.H() phi << ( ref.fvc.interpolate( U ) & mesh.Sf() ) + ref.fvc.ddtPhiCorr( rAU, U, phi ) ref.adjustPhi(phi, U, p) for nonOrth in range( nNonOrthCorr + 1): pEqn = ( ref.fvm.laplacian( rAU, p ) == ref.fvc.div( phi ) ) pEqn.setReference( pRefCell, pRefValue ) pEqn.solve() if nonOrth == nNonOrthCorr: phi -= pEqn.flux() pass pass cumulativeContErr = ref.ContinuityErrs( phi, runTime, mesh, cumulativeContErr ) U -= rAU * ref.fvc.grad( p ) U.correctBoundaryConditions() pass runTime.write() ref.ext_Info() << "ExecutionTime = " << runTime.elapsedCpuTime() << " s" << \ " ClockTime = " << runTime.elapsedClockTime() << " s" << ref.nl << ref.nl pass ref.ext_Info() << "End\n" << ref.nl import os return os.EX_OK
def fun_Ueqn(rho, U, phi, turbulence, p): UEqn = man.fvm.ddt(rho, U) + man.fvm.div(phi, U) + man( turbulence.divDevRhoReff(U()), man.Deps(turbulence, U)) ref.solve(UEqn == -man.fvc.grad(p)) return UEqn
def main_standalone(argc, argv): args = ref.setRootCase(argc, argv) runTime = man.createTime(args) mesh = man.createMeshNoClear(runTime) transportProperties, nu = readTransportProperties(runTime, mesh) p, U, phi = _createFields(runTime, mesh) turbulenceProperties, force, K, forceGen = readTurbulenceProperties( runTime, mesh, U) cumulativeContErr = ref.initContinuityErrs() # * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * # ref.ext_Info() << "\nStarting time loop\n" while runTime.loop(): ref.ext_Info() << "Time = " << runTime.timeName() << ref.nl << ref.nl piso, nCorr, nNonOrthCorr, momentumPredictor, transonic, nOuterCorr = ref.readPISOControls( mesh) force.internalField() << (ref.ReImSum( ref.fft.reverseTransform( K / (K.mag() + 1.0e-6) ^ forceGen.newField(), K.nn()))) globalProperties(runTime, U, nu, force) UEqn = ref.fvm.ddt(U) + ref.fvm.div(phi, U) - ref.fvm.laplacian( nu, U) == force ref.solve(UEqn == -man.fvc.grad(p)) # --- PISO loop for corr in range(1): rUA = 1.0 / UEqn.A() U << rUA * UEqn.H() phi << (ref.fvc.interpolate(U) & mesh.Sf()) + ref.fvc.ddtPhiCorr( rUA, U, phi) pEqn = ref.fvm.laplacian(rUA, p) == ref.fvc.div(phi) pEqn.solve() phi -= pEqn.flux() cumulativeContErr = ref.ContinuityErrs(phi, runTime, mesh, cumulativeContErr) U -= rUA * ref.fvc.grad(p) U.correctBoundaryConditions() pass runTime.write() if runTime.outputTime(): ref.calcEk(U, K).ext_write( ref.fileName(runTime.path()) / ref.fileName("graphs") / ref.fileName(runTime.timeName()), ref.word("Ek"), runTime.graphFormat()) pass ref.ext_Info() << "ExecutionTime = " << runTime.elapsedCpuTime() << " s" \ << " ClockTime = " << runTime.elapsedClockTime() << " s" << ref.nl << ref.nl pass ref.ext_Info() << "End\n" << ref.nl import os return os.EX_OK
def main_standalone(argc, argv): args = ref.setRootCase(argc, argv) runTime = man.createTime(args) mesh = man.createMesh(runTime) p, U, phi, pa, Ua, phia, alpha, laminarTransport, turbulence, zeroSensitivity, zeroAlpha, \ lambda_, alphaMax, inletCells, pRefCell, pRefValue, paRefCell, paRefValue = createFields( runTime, mesh ) cumulativeContErr = ref.initContinuityErrs() cumulativeAdjointContErr = initAdjointContinuityErrs() simple = man.simpleControl(mesh) ref.ext_Info() << "\nStarting time loop\n" << ref.nl while simple.loop(): ref.ext_Info() << "Time = " << runTime.timeName() << ref.nl << ref.nl laminarTransport.lookup(ref.word("lambda")) >> lambda_ alpha += mesh.fieldRelaxationFactor(ref.word("alpha")) * (( (alpha + lambda_ * (Ua & U)).ext_max(zeroAlpha)).ext_min(alphaMax) - alpha) zeroCells(alpha, inletCells) UEqn = ref.fvm.div(phi, U) + turbulence.divDevReff(U) + ref.fvm.Sp( alpha, U) UEqn.relax() ref.solve(UEqn == -ref.fvc.grad(p)) p.ext_boundaryField().updateCoeffs() rAU = 1.0 / UEqn.A() U << rAU * UEqn.H() phi << (ref.fvc.interpolate(U) & mesh.Sf()) ref.adjustPhi(phi, U, p) 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() # Adjoint Pressure-velocity SIMPLE corrector # Adjoint Momentum predictor adjointTransposeConvection = (ref.fvc.grad(Ua) & U) # adjointTransposeConvection = ref.fvc.reconstruct( mesh.magSf() * ( ref.fvc.snGrad( Ua ) & ref.fvc.interpolate( U ) ) ) zeroCells(adjointTransposeConvection, inletCells) UaEqn = ref.fvm.div( -phi, Ua) - adjointTransposeConvection + turbulence.divDevReff( Ua) + ref.fvm.Sp(alpha, Ua) UaEqn.relax() ref.solve(UaEqn == -ref.fvc.grad(pa)) pa.ext_boundaryField().updateCoeffs() rAUa = 1.0 / UaEqn.A() Ua << rAUa * UaEqn.H() UaEqn.clear() phia << (ref.fvc.interpolate(Ua) & mesh.Sf()) ref.adjustPhi(phia, Ua, pa) # Non-orthogonal pressure corrector loop while simple.correctNonOrthogonal(): paEqn = ref.fvm.laplacian(rAUa, pa) == ref.fvc.div(phia) paEqn.setReference(paRefCell, paRefValue) paEqn.solve() if simple.finalNonOrthogonalIter(): phia -= paEqn.flux() pass pass cumulativeAdjointContErr = adjointContinuityErrs( runTime, mesh, phia, cumulativeAdjointContErr) # Explicitly relax pressure for adjoint momentum corrector pa.relax() # Adjoint momentum corrector Ua -= rAUa * ref.fvc.grad(pa) Ua.correctBoundaryConditions() turbulence.correct() runTime.write() ref.ext_Info()<< "ExecutionTime = " << runTime.elapsedCpuTime() << " s\n\n" \ << ref.nl pass ref.ext_Info() << "End\n" << ref.nl import os return os.EX_OK
def main_standalone( argc, argv ): args = ref.setRootCase( argc, argv ) runTime = man.createTime( args ) mesh = man.createMeshNoClear( runTime ) transportProperties, nu = readTransportProperties( runTime, mesh ) p, U, phi = _createFields( runTime, mesh ) turbulenceProperties, force, K, forceGen = readTurbulenceProperties( runTime, mesh, U ) cumulativeContErr = ref.initContinuityErrs() # * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * # ref.ext_Info() << "\nStarting time loop\n" while runTime.loop(): ref.ext_Info() << "Time = " << runTime.timeName() << ref.nl << ref.nl piso, nCorr, nNonOrthCorr, momentumPredictor, transonic, nOuterCorr = ref.readPISOControls( mesh ) force.internalField() << ( ref.ReImSum( ref.fft.reverseTransform( K / ( K.mag() + 1.0e-6 ) ^ forceGen.newField(), K.nn() ) ) ) globalProperties( runTime, U, nu, force ) UEqn = ref.fvm.ddt( U ) + ref.fvm.div( phi, U ) - ref.fvm.laplacian( nu, U ) == force ref.solve( UEqn == - man.fvc.grad( p ) ) # --- PISO loop for corr in range( 1 ): rUA = 1.0 / UEqn.A() U << rUA * UEqn.H() phi << ( ref.fvc.interpolate( U ) & mesh.Sf() ) + ref.fvc.ddtPhiCorr( rUA, U, phi ) pEqn = ref.fvm.laplacian( rUA, p ) == ref.fvc.div( phi ) pEqn.solve() phi -= pEqn.flux() cumulativeContErr = ref.ContinuityErrs( phi, runTime, mesh, cumulativeContErr ) U -= rUA * ref.fvc.grad( p ) U.correctBoundaryConditions() pass runTime.write() if runTime.outputTime(): ref.calcEk( U, K ).ext_write( ref.fileName( runTime.path() )/ref.fileName("graphs")/ref.fileName( runTime.timeName() ), ref.word( "Ek" ), runTime.graphFormat() ) pass ref.ext_Info() << "ExecutionTime = " << runTime.elapsedCpuTime() << " s" \ << " ClockTime = " << runTime.elapsedClockTime() << " s" << ref.nl << ref.nl pass ref.ext_Info() << "End\n" << ref.nl import os return os.EX_OK
def main_standalone(argc, argv): args = ref.setRootCase(argc, argv) runTime = man.createTime(args) mesh = man.createMesh(runTime) gravitationalProperties, g, rotating, Omega, magg, gHat = readGravitationalAcceleration( runTime, mesh) h, h0, U, hU, hTotal, phi, F = _createFields(runTime, mesh, Omega, gHat) pimple = man.pimpleControl(mesh) ref.ext_Info() << "\nStarting time loop\n" << ref.nl while runTime.loop(): ref.ext_Info() << "\n Time = " << runTime.timeName( ) << ref.nl << ref.nl CourantNo(runTime, mesh, h, phi, magg) pimple.start() while pimple.loop(): phiv = ref.surfaceScalarField( ref.word("phiv"), phi() / ref.fvc.interpolate(h)) # mixed calculations hUEqn = ref.fvm.ddt(hU) + ref.fvm.div(phiv, hU) hUEqn.relax() if pimple.momentumPredictor(): if rotating: ref.solve(hUEqn + (F ^ hU) == -magg * h * ref.fvc.grad(h + h0)) pass else: ref.solve(hUEqn == -magg * h * ref.fvc.grad(h + h0)) pass # Constrain the momentum to be in the geometry if 3D geometry if mesh.nGeometricD() == 3: hU -= (gHat & hU) * gHat hU.correctBoundaryConditions() pass for corr in range(pimple.nCorr()): hf = ref.fvc.interpolate(h) rUA = 1.0 / hUEqn.A() ghrUAf = magg * ref.fvc.interpolate(h * rUA) phih0 = ghrUAf * mesh.magSf() * ref.fvc.snGrad(h0) if rotating: hU << rUA * (hUEqn.H() - (F ^ hU)) pass else: hU << rUA * hUEqn.H() pass phi << (ref.fvc.interpolate(hU) & mesh.Sf() ) + ref.fvc.ddtPhiCorr(rUA, h, hU, phi) - phih0 for nonOrth in range(pimple.nNonOrthCorr() + 1): hEqn = ref.fvm.ddt(h) + ref.fvc.div( phi) - ref.fvm.laplacian(ghrUAf, h) hEqn.solve( mesh.solver( h.select(pimple.finalInnerIter(corr, nonOrth)))) if nonOrth == pimple.nNonOrthCorr(): phi += hEqn.flux() pass hU -= rUA * h * magg * ref.fvc.grad(h + h0) #Constrain the momentum to be in the geometry if 3D geometry if mesh.nGeometricD() == 3: hU -= (gHat & hU) * gHat pass hU.correctBoundaryConditions() pass pimple.increment() pass U == hU / h hTotal == h + h0 runTime.write() ref.ext_Info() << "ExecutionTime = " << runTime.elapsedCpuTime() << " s" << \ " ClockTime = " << runTime.elapsedClockTime() << " s" << ref.nl << ref.nl pass ref.ext_Info() << "End\n" << ref.nl import os return os.EX_OK
def step(self): if self.runTime_.end(): ref.ext_Info() << "Reached end time. Exiting" << ref.nl return self.runTime_.increment() # Read transport properties nu = ref.dimensionedScalar(self.transportProperties_.lookup(ref.word("nu"))) if self.mesh_.nInternalFaces(): SfUfbyDelta = self.mesh_.deltaCoeffs() * self.phi_.mag() CoNum = (SfUfbyDelta / self.mesh_.magSf()).ext_max().value() * self.runTime_.deltaT().value() meanCoNum = (SfUfbyDelta.sum() / self.mesh_.magSf().sum()).value() * self.runTime_.deltaT().value() ref.ext_Info() << "Courant Number mean: " << meanCoNum << " max: " << CoNum << ref.nl pass # Read controls piso = self.mesh_.solutionDict().subDict(ref.word("PISO")) nCorr = ref.readInt(piso.lookup(ref.word("nCorrectors"))) nNonOrthCorr = 0 if piso.found(ref.word("nNonOrthogonalCorrectors")): nNonOrthCorr = ref.readInt(piso.lookup(ref.word("nNonOrthogonalCorrectors"))) pass UEqn = ref.fvm.ddt(self.U_) + ref.fvm.div(self.phi_, self.U_) - ref.fvm.laplacian(nu, self.U_) self.velocityRes_ = ref.solve(UEqn == -ref.fvc.grad(self.p_)).initialResidual() # --- PISO loop for corr in range(nCorr): rUA = 1.0 / UEqn.A() self.U_ << rUA * UEqn.H() self.phi_ << (ref.fvc.interpolate(self.U_) & self.mesh_.Sf()) + ref.fvc.ddtPhiCorr(rUA, self.U_, self.phi_) # adjustPhi(phi_, U_, p_); for nonOrth in range(nNonOrthCorr + 1): pEqn = ref.fvm.laplacian(rUA, self.p_) == ref.fvc.div(self.phi_) pEqn.setReference(self.pRefCell_, self.pRefValue_) self.pressureRes_ = pEqn.solve().initialResidual() if nonOrth == nNonOrthCorr: self.phi_ -= pEqn.flux() pass pass # Continuity errors contErr = ref.fvc.div(self.phi_) sumLocalContErr = self.runTime_.deltaT().value() * contErr.mag().weightedAverage(self.mesh_.V()).value() globalContErr = self.runTime_.deltaT().value() * contErr.weightedAverage(self.mesh_.V()).value() ref.ext_Info() << "time step continuity errors : sum local = " << sumLocalContErr << ", global = " << globalContErr << ref.nl # Correct velocity self.U_ -= rUA * ref.fvc.grad(self.p_) self.U_.correctBoundaryConditions() pass
def main_standalone(argc, argv): args = ref.setRootCase(argc, argv) runTime = man.createTime(args) mesh = man.createMesh(runTime) thermodynamicProperties, rho0, p0, psi, rhoO = readThermodynamicProperties( runTime, mesh) transportProperties, mu = readTransportProperties(runTime, mesh) p, U, rho, phi = createFields(runTime, mesh, rhoO, psi) cumulativeContErr = ref.initContinuityErrs() #// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // ref.ext_Info() << "\nStarting time loop\n" << ref.nl while runTime.loop(): ref.ext_Info() << "Time = " << runTime.timeName() << ref.nl << ref.nl piso, nCorr, nNonOrthCorr, momentumPredictor, transonic, nOuterCorr = ref.readPISOControls( mesh) CoNum, meanCoNum = ref.compressibleCourantNo(mesh, phi, rho, runTime) ref.rhoEqn(rho, phi) UEqn = man.fvm.ddt(rho, U) + man.fvm.div(phi, U) - man.fvm.laplacian( mu, U) ref.solve(UEqn == -man.fvc.grad(p)) # --- PISO loop for corr in range(nCorr): rAU = 1.0 / UEqn.A() U << rAU * UEqn.H() phid = ref.surfaceScalarField( ref.word("phid"), psi * ((ref.fvc.interpolate(U) & mesh.Sf()) + ref.fvc.ddtPhiCorr(rAU, rho(), U(), phi()))) phi << (rhoO / psi) * phid pEqn = ref.fvm.ddt(psi, p()) + ref.fvc.div(phi()) + ref.fvm.div( phid, p()) - ref.fvm.laplacian(rho() * rAU, p()) pEqn.solve() phi += pEqn.flux() cumulativeContErr = compressibleContinuityErrs( rho, phi, p, rho0, p0, psi, cumulativeContErr) U -= rAU * ref.fvc.grad(p) U.correctBoundaryConditions() pass rho << rhoO + psi * p runTime.write() ref.ext_Info()<< "ExecutionTime = " << runTime.elapsedCpuTime() << " s" \ << " ClockTime = " << runTime.elapsedClockTime() << " s" \ << ref.nl << ref.nl pass ref.ext_Info() << "End\n" << ref.nl import os return os.EX_OK
def main_standalone( argc, argv ): args = ref.setRootCase( argc, argv ) runTime = man.createTime( args ) mesh = man.createMesh( runTime ) thermo, p, e, T, psi, mu, U, pbf, rhoBoundaryTypes, rho, rhoU, rhoE, pos, \ neg, inviscid, phi, turbulence = _createFields( runTime, mesh ) thermophysicalProperties, Pr = readThermophysicalProperties( runTime, mesh ) fluxScheme = readFluxScheme( mesh ) v_zero = ref.dimensionedScalar( ref.word( "v_zero" ), ref.dimVolume / ref.dimTime, 0.0) ref.ext_Info() << "\nStarting time loop\n" << ref.nl while runTime.run() : # --- upwind interpolation of primitive fields on faces rho_pos = ref.fvc.interpolate( rho, pos, ref.word( "reconstruct(rho)" ) ) rho_neg = ref.fvc.interpolate( rho, neg, ref.word( "reconstruct(rho)" ) ) rhoU_pos = ref.fvc.interpolate( rhoU, pos, ref.word( "reconstruct(U)" ) ) rhoU_neg = ref.fvc.interpolate( rhoU, neg, ref.word( "reconstruct(U)" ) ) rPsi = 1.0 / psi rPsi_pos = ref.fvc.interpolate( rPsi, pos, ref.word( "reconstruct(T)" ) ) rPsi_neg = ref.fvc.interpolate( rPsi, neg, ref.word( "reconstruct(T)" ) ) e_pos = ref.fvc.interpolate( e, pos, ref.word( "reconstruct(T)" ) ) e_neg = ref.fvc.interpolate( e, neg, ref.word( "reconstruct(T)" ) ) U_pos = rhoU_pos / rho_pos U_neg = rhoU_neg / rho_neg p_pos = rho_pos * rPsi_pos p_neg = rho_neg * rPsi_neg phiv_pos = U_pos & mesh.Sf() phiv_neg = U_neg & mesh.Sf() c = ( thermo.Cp() / thermo.Cv() * rPsi ).sqrt() cSf_pos = ref.fvc.interpolate( c, pos, ref.word( "reconstruct(T)" ) ) * mesh.magSf() cSf_neg = ref.fvc.interpolate( c, neg, ref.word( "reconstruct(T)" ) ) * mesh.magSf() ap = ( phiv_pos + cSf_pos ).ext_max( phiv_neg + cSf_neg ).ext_max( v_zero ) am = ( phiv_pos - cSf_pos ).ext_min( phiv_neg - cSf_neg ).ext_min( v_zero ) a_pos = ap / ( ap - am ) amaxSf = ref.surfaceScalarField( ref.word( "amaxSf" ), am.mag().ext_max( ap.mag() ) ) aSf = am * a_pos if str( fluxScheme ) == "Tadmor": aSf << -0.5 * amaxSf a_pos << 0.5 pass a_neg = 1.0 - a_pos phiv_pos *= a_pos phiv_neg *= a_neg aphiv_pos = phiv_pos - aSf aphiv_neg = phiv_neg + aSf # Reuse amaxSf for the maximum positive and negative fluxes # estimated by the central scheme amaxSf << aphiv_pos.mag().ext_max( aphiv_neg.mag() ) CoNum, meanCoNum = compressibleCourantNo( mesh, amaxSf, runTime ) adjustTimeStep, maxCo, maxDeltaT = ref.readTimeControls( runTime ) runTime = ref.setDeltaT( runTime, adjustTimeStep, maxCo, maxDeltaT, CoNum ) runTime.increment() ref.ext_Info() << "Time = " << runTime.timeName() << ref.nl << ref.nl phi << aphiv_pos * rho_pos + aphiv_neg * rho_neg phiUp = ( aphiv_pos * rhoU_pos + aphiv_neg * rhoU_neg) + ( a_pos * p_pos + a_neg * p_neg ) * mesh.Sf() phiEp = aphiv_pos * ( rho_pos * ( e_pos + 0.5*U_pos.magSqr() ) + p_pos ) + aphiv_neg * ( rho_neg * ( e_neg + 0.5 * U_neg.magSqr() ) + p_neg )\ + aSf * p_pos - aSf * p_neg muEff = turbulence.muEff() tauMC = ref.volTensorField( ref.word( "tauMC" ) , muEff * ref.fvc.grad(U).T().dev2() ) # --- Solve density ref.solve( ref.fvm.ddt( rho ) + ref.fvc.div( phi ) ) # --- Solve momentum ref.solve( ref.fvm.ddt( rhoU ) + ref.fvc.div( phiUp ) ) U.dimensionedInternalField() << rhoU.dimensionedInternalField() / rho.dimensionedInternalField() U.correctBoundaryConditions() rhoU.ext_boundaryField() << rho.ext_boundaryField() * U.ext_boundaryField() rhoBydt = rho / runTime.deltaT() if not inviscid: solve( fvm.ddt( rho, U ) - fvc.ddt( rho, U ) - fvm.laplacian( muEff, U ) - fvc.div( tauMC ) ) rhoU << rho * U pass # --- Solve energy sigmaDotU = ( ref.fvc.interpolate( muEff ) * mesh.magSf() * ref.fvc.snGrad( U ) + ( mesh.Sf() & ref.fvc.interpolate( tauMC ) ) ) & ( a_pos * U_pos + a_neg * U_neg ) ref.solve( ref.fvm.ddt( rhoE ) + ref.fvc.div( phiEp ) - ref.fvc.div( sigmaDotU ) ) e << rhoE() / rho() - 0.5 * U.magSqr() # mixed calculations e.correctBoundaryConditions() thermo.correct() rhoE.ext_boundaryField() << rho.ext_boundaryField() * ( e.ext_boundaryField() + 0.5 * U.ext_boundaryField().magSqr() ) if not inviscid : k = man.volScalarField( ref.word( "k" ) , thermo.Cp() * muEff / Pr ) # The initial C++ expression does not work properly, because of # 1. the order of expression arguments computation differs with C++ #solve( fvm.ddt( rho, e ) - fvc.ddt( rho, e ) - fvm.laplacian( thermo.alpha(), e ) \ # + fvc.laplacian( thermo.alpha(), e ) - fvc.laplacian( k, T ) ) solve( -fvc.laplacian( k, T ) + ( fvc.laplacian( turbulence.alpha(), e ) \ + (- fvm.laplacian( turbulence.alphaEff(), e ) + (- fvc.ddt( rho, e ) + fvm.ddt( rho, e ) ) ) ) ) thermo.correct() rhoE << rho * ( e + 0.5 * U.magSqr() ) pass p.dimensionedInternalField() << rho.dimensionedInternalField() / psi.dimensionedInternalField() p.correctBoundaryConditions() rho.ext_boundaryField() << psi.ext_boundaryField() * p.ext_boundaryField() turbulence.correct() runTime.write() ref.ext_Info() << "ExecutionTime = " << runTime.elapsedCpuTime() << " s" << \ " ClockTime = " << runTime.elapsedClockTime() << " s" << ref.nl << ref.nl pass ref.ext_Info() << "End\n" import os return os.EX_OK
def main_standalone(argc, argv): args = ref.setRootCase(argc, argv) runTime = man.createTime(args) mesh = man.createMesh(runTime) p, U, phi, turbulence, pRefCell, pRefValue, laminarTransport = _createFields(runTime, mesh) cumulativeContErr = ref.initContinuityErrs() ref.ext_Info() << "\nStarting time loop\n" << ref.nl while runTime.loop(): ref.ext_Info() << "Time = " << runTime.timeName() << ref.nl << ref.nl piso, nCorr, nNonOrthCorr, momentumPredictor, transonic, nOuterCorr = ref.readPISOControls(mesh) CoNum, meanCoNum = ref.CourantNo(mesh, phi, runTime) # Pressure-velocity PISO corrector # Momentum predictor # 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.ddt( U ) + fvm.div( phi, U ) + turbulence.divDevReff( U ) UEqn = turbulence.divDevReff(U) + (ref.fvm.ddt(U) + ref.fvm.div(phi, U)) UEqn.relax() if momentumPredictor: ref.solve(UEqn == -ref.fvc.grad(p)) pass # --- PISO loop for corr in range(nCorr): rUA = 1.0 / UEqn.A() U << rUA * UEqn.H() phi << (ref.fvc.interpolate(U) & mesh.Sf()) + ref.fvc.ddtPhiCorr(rUA, U, phi) ref.adjustPhi(phi, U, p) # Non-orthogonal pressure corrector loop for nonOrth in range(nNonOrthCorr + 1): # Pressure corrector pEqn = ref.fvm.laplacian(rUA, p) == ref.fvc.div(phi) pEqn.setReference(pRefCell, pRefValue) if corr == (nCorr - 1) and nonOrth == nNonOrthCorr: pEqn.solve(mesh.solver(ref.word("pFinal"))) pass else: pEqn.solve() pass if nonOrth == nNonOrthCorr: phi -= pEqn.flux() pass pass cumulativeContErr = ref.ContinuityErrs(phi, runTime, mesh, cumulativeContErr) U -= rUA * ref.fvc.grad(p) U.correctBoundaryConditions() pass turbulence.correct() runTime.write() ref.ext_Info() << "ExecutionTime = " << runTime.elapsedCpuTime() << " s" << " ClockTime = " << runTime.elapsedClockTime() << " s" << ref.nl << ref.nl pass ref.ext_Info() << "End\n" << ref.nl import os return os.EX_OK
def main_standalone( argc, argv ): args = ref.setRootCase( argc, argv ) runTime = man.createTime( args ) mesh = man.createMesh( runTime ) p, U, phi, turbulence, pRefCell, pRefValue, laminarTransport = _createFields( runTime, mesh ) cumulativeContErr = ref.initContinuityErrs() ref.ext_Info() << "\nStarting time loop\n" <<ref.nl while runTime.loop() : ref.ext_Info() << "Time = " << runTime.timeName() << ref.nl << ref.nl piso, nCorr, nNonOrthCorr, momentumPredictor, transonic, nOuterCorr = ref.readPISOControls( mesh ) CoNum, meanCoNum = ref.CourantNo( mesh, phi, runTime ) # Pressure-velocity PISO corrector # Momentum predictor # 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.ddt( U ) + fvm.div( phi, U ) + turbulence.divDevReff( U ) UEqn = turbulence.divDevReff( U ) + ( ref.fvm.ddt( U ) + ref.fvm.div( phi, U ) ) UEqn.relax() if momentumPredictor : ref.solve( UEqn == -ref.fvc.grad( p ) ) pass # --- PISO loop for corr in range( nCorr ) : rUA = 1.0 / UEqn.A() U << rUA * UEqn.H() phi << ( ref.fvc.interpolate(U) & mesh.Sf() ) + ref.fvc.ddtPhiCorr( rUA, U, phi ) ref.adjustPhi( phi, U, p ) # Non-orthogonal pressure corrector loop for nonOrth in range( nNonOrthCorr + 1 ): # Pressure corrector pEqn = ref.fvm.laplacian( rUA, p ) == ref.fvc.div( phi ) pEqn.setReference( pRefCell, pRefValue ) if corr == ( nCorr-1 ) and nonOrth == nNonOrthCorr : pEqn.solve( mesh.solver( ref.word( "pFinal" ) ) ) pass else: pEqn.solve() pass if nonOrth == nNonOrthCorr: phi -= pEqn.flux() pass pass cumulativeContErr = ref.ContinuityErrs( phi, runTime, mesh, cumulativeContErr ) U -= rUA * ref.fvc.grad( p ) U.correctBoundaryConditions() pass turbulence.correct() runTime.write() ref.ext_Info() << "ExecutionTime = " << runTime.elapsedCpuTime() << " s" << \ " ClockTime = " << runTime.elapsedClockTime() << " s" << ref.nl << ref.nl pass ref.ext_Info() << "End\n" << ref.nl import os return os.EX_OK
def main_standalone(argc, argv): args = ref.setRootCase(argc, argv) runTime = man.createTime(args) mesh = man.createMesh(runTime) gravitationalProperties, g, rotating, Omega, magg, gHat = readGravitationalAcceleration(runTime, mesh) h, h0, U, hU, hTotal, phi, F = _createFields(runTime, mesh, Omega, gHat) pimple = man.pimpleControl(mesh) ref.ext_Info() << "\nStarting time loop\n" << ref.nl while runTime.loop(): ref.ext_Info() << "\n Time = " << runTime.timeName() << ref.nl << ref.nl CourantNo(runTime, mesh, h, phi, magg) pimple.start() while pimple.loop(): phiv = ref.surfaceScalarField(ref.word("phiv"), phi() / ref.fvc.interpolate(h)) # mixed calculations hUEqn = ref.fvm.ddt(hU) + ref.fvm.div(phiv, hU) hUEqn.relax() if pimple.momentumPredictor(): if rotating: ref.solve(hUEqn + (F ^ hU) == -magg * h * ref.fvc.grad(h + h0)) pass else: ref.solve(hUEqn == -magg * h * ref.fvc.grad(h + h0)) pass # Constrain the momentum to be in the geometry if 3D geometry if mesh.nGeometricD() == 3: hU -= (gHat & hU) * gHat hU.correctBoundaryConditions() pass for corr in range(pimple.nCorr()): hf = ref.fvc.interpolate(h) rUA = 1.0 / hUEqn.A() ghrUAf = magg * ref.fvc.interpolate(h * rUA) phih0 = ghrUAf * mesh.magSf() * ref.fvc.snGrad(h0) if rotating: hU << rUA * (hUEqn.H() - (F ^ hU)) pass else: hU << rUA * hUEqn.H() pass phi << (ref.fvc.interpolate(hU) & mesh.Sf()) + ref.fvc.ddtPhiCorr(rUA, h, hU, phi) - phih0 for nonOrth in range(pimple.nNonOrthCorr() + 1): hEqn = ref.fvm.ddt(h) + ref.fvc.div(phi) - ref.fvm.laplacian(ghrUAf, h) hEqn.solve(mesh.solver(h.select(pimple.finalInnerIter(corr, nonOrth)))) if nonOrth == pimple.nNonOrthCorr(): phi += hEqn.flux() pass hU -= rUA * h * magg * ref.fvc.grad(h + h0) # Constrain the momentum to be in the geometry if 3D geometry if mesh.nGeometricD() == 3: hU -= (gHat & hU) * gHat pass hU.correctBoundaryConditions() pass pimple.increment() pass U == hU / h hTotal == h + h0 runTime.write() ref.ext_Info() << "ExecutionTime = " << runTime.elapsedCpuTime() << " s" << " ClockTime = " << runTime.elapsedClockTime() << " s" << ref.nl << ref.nl pass ref.ext_Info() << "End\n" << ref.nl import os return os.EX_OK
def main_standalone(argc, argv): args = ref.setRootCase(argc, argv) runTime = man.createTime(args) mesh = man.createMesh(runTime) g = man.readGravitationalAcceleration(runTime, mesh) pimple = ref.pimpleControl(mesh) adjustTimeStep, maxCo, maxDeltaT, nAlphaCorr, nAlphaSubCycles = read_controls( args, runTime, pimple) cumulativeContErr = ref.initContinuityErrs() p_rgh, alpha1, alpha2, U, phi, twoPhaseProperties, rho10, rho20, psi1, psi2, pMin, \ gh, ghf, p, rho1, rho2, rho, rhoPhi, dgdt, interface, turbulence = _createFields( runTime, mesh, g ) CoNum, meanCoNum = ref.CourantNo(mesh, phi, runTime) runTime = ref.setInitialDeltaT(runTime, adjustTimeStep, maxCo, CoNum) # * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * # ref.ext_Info() << "\nStarting time loop\n" << ref.nl while runTime.run(): adjustTimeStep, maxCo, maxDeltaT, nAlphaCorr, nAlphaSubCycles = read_controls( args, runTime, pimple) CoNum, meanCoNum = ref.CourantNo(mesh, phi, runTime) runTime = ref.setDeltaT(runTime, adjustTimeStep, maxCo, maxDeltaT, CoNum) runTime.increment() ref.ext_Info() << "Time = " << runTime.timeName() << ref.nl << ref.nl # --- Outer-corrector loop pimple.start() while pimple.loop(): alphaEqnsSubCycle(runTime, pimple, mesh, phi, alpha1, alpha2, rho, rho1, rho2, rhoPhi, dgdt, interface) ref.solve(ref.fvm.ddt(rho) + ref.fvc.div(rhoPhi)) UEqn = fun_UEqn(mesh, alpha1, U, p, p_rgh, ghf, rho, rhoPhi, turbulence, g, twoPhaseProperties, interface, pimple) # --- PISO loop for corr in range(pimple.nCorr()): fun_pEqn( runTime, mesh, pimple, UEqn, p, p_rgh, phi, U, rho, rho1, rho2, rho10, rho20, gh, ghf, dgdt, pMin, \ psi1, psi2, alpha1, alpha2, interface, corr ) pass if pimple.turbCorr(): turbulence.correct() pass pimple.increment() pass rho << alpha1 * rho1 + alpha2 * rho2 runTime.write() ref.ext_Info() << "ExecutionTime = " << runTime.elapsedCpuTime( ) << " s\n\n" << ref.nl pass ref.ext_Info() << "End\n" << ref.nl import os return os.EX_OK
def main_standalone( argc, argv ): args = ref.setRootCase( argc, argv ) runTime = man.createTime( args ) mesh = man.createMesh( runTime ) transportProperties, nu, p, U, phi, pRefCell, pRefValue = createFields( runTime, mesh ) cumulativeContErr = ref.initContinuityErrs() ref.ext_Info() << "\nStarting time loop\n" while runTime.loop() : ref.ext_Info() << "Time = " << runTime.timeName() << ref.nl << ref.nl piso, nCorr, nNonOrthCorr, momentumPredictor, transonic, nOuterCorr = ref.readPISOControls( mesh ) CoNum, meanCoNum = ref.CourantNo( mesh, phi, runTime ) UEqn = man.fvm.ddt( U ) + man.fvm.div( phi, U ) - man.fvm.laplacian( nu, U ) ref.solve( UEqn == -man.fvc.grad( p ) ) # --- PISO loop for corr in range( nCorr ) : rUA = 1.0 / UEqn.A() U << rUA * UEqn.H() phi << ( ref.fvc.interpolate( U ) & mesh.Sf() ) + ref.fvc.ddtPhiCorr( rUA, U, phi ) ref.adjustPhi( phi, U, p ) for nonOrth in range( nNonOrthCorr + 1 ) : pEqn = ( ref.fvm.laplacian( rUA, p ) == ref.fvc.div( phi ) ) pEqn.setReference( pRefCell, pRefValue ) pEqn.solve() if nonOrth == nNonOrthCorr: phi -= pEqn.flux() pass pass cumulativeContErr = ref.ContinuityErrs( phi, runTime, mesh, cumulativeContErr ) U -= rUA * ref.fvc.grad( p ) U.correctBoundaryConditions() pass runTime.write() ref.ext_Info() << "ExecutionTime = " << runTime.elapsedCpuTime() << " s" << \ " ClockTime = " << runTime.elapsedClockTime() << " s" << ref.nl << ref.nl pass ref.ext_Info() << "End\n" import os return os.EX_OK