def gridAdv(npts, cfl=1.0): # Define the domain/mesh xf = 1.0 * (npts - 1) / npts domain = "xdom = (0.0 , xf , npts , periodic=True)" domain = domain.replace('xf', str(xf)) domain = domain.replace('npts', str(npts)) # Initialize a simulation object on a mesh pysim = pyrandaSim('advection', domain, silent=True) # Define the equations of motion pysim.EOM(" ddt(:phi:) = -:c: * ddx(:phi:) ") # Initialize variables ic = """ :phi: = 1.0 + 0.1 * exp( -(abs(meshx-.5)/.1 )**2 ) :phi0: = :phi: :c: = 1.0 """ pysim.setIC(ic) # Integrate in time dt = 1.0 / (npts - 1) / 1.0 * cfl time = 0.0 tfinal = 1.0 while time < tfinal: time = pysim.rk4(time, dt) dt = min(dt, (tfinal - time)) x = pysim.mesh.coords[0].data phi = pysim.variables['phi'].data phi0 = pysim.variables['phi0'].data error = numpy.sum(numpy.abs(phi - phi0)) return error
mesh_options = {} mesh_options['coordsys'] = 0 mesh_options['periodic'] = numpy.array([twoD, twoD, True]) mesh_options['dim'] = 3 mesh_options['x1'] = [0.0, 0.0, 0.0] mesh_options['xn'] = [Lp, Lp, Lp] #mesh_options['x1'] = [ -Lp/2.0 , -Lp/2.0 , 0.0 ] #mesh_options['xn'] = [ Lp/2.0 , Lp/2.0 , Lp ] mesh_options['nn'] = [Npts, 1, 1] if twoD: mesh_options['nn'] = [Npts, Npts, 1] # Initialize a simulation object on a mesh ss = pyrandaSim('swirl', mesh_options) ss.addPackage(pyrandaIBM(ss)) # Define the equations of motion eom = """ # Primary Equations of motion here ddt(:rho:) = -ddx(:rho:*:u: - :tau:) - ddy(:rho:*:v: - :tau:) ddt(:rhoA:) = -ddx(:rhoA:*:uA: - :tauA:) -ddy(:rhoA:*:vA: - :tauA:) ddt(:phi:) = - :gx: * :u1: - :gy: * :v1: - .01*sign(:phi:)*(:mgp:-1.0) # Conservative filter of the EoM :rho: = fbar( :rho: ) :rhoA: = fbar( :rhoA: ) #:phi: = fbar( :phi: ) # Update the primatives and enforce the EOS :dr: = ddx(:rho:) :drA: = ddx(:rhoA:)
except: test = False problem = 'RM_theta' ## Define a mesh Npts = 64 imesh = """ xdom = (0.0, 2.8*pi , int(Npts*1.4), periodic=False) ydom = (0.0, 2*pi*FF, Npts, periodic=True) zdom = (0.0, 2*pi*FF, 1, periodic=True) """.replace('Npts', str(Npts)).replace('pi', str(numpy.pi)).replace( 'FF', str(float(Npts - 1) / Npts)) # Initialize a simulation object on a mesh ss = pyrandaSim(problem, imesh) ss.addPackage(pyrandaTimestep(ss)) ss.addPackage(pyrandaBC(ss)) # Define the equations of motion eom = """ # Primary Equations of motion here ddt(:rhoYh:) = -ddx(:rhoYh:*:u: - :Jx:) - ddy(:rhoYh:*:v: - :Jy:) - ddz(:rhoYh:*:w: - :Jz:) ddt(:rhoYl:) = -ddx(:rhoYl:*:u: + :Jx:) - ddy(:rhoYl:*:v: + :Jy:) - ddz(:rhoYl:*:w: + :Jz:) ddt(:rhou:) = -ddx(:rhou:*:u: - :tauxx:) - ddy(:rhou:*:v: - :tauxy:) - ddz(:rhou:*:w: - :tauxz:) ddt(:rhov:) = -ddx(:rhov:*:u: - :tauxy:) - ddy(:rhov:*:v: - :tauyy:) - ddz(:rhov:*:w: - :tauyz:) ddt(:rhow:) = -ddx(:rhow:*:u: - :tauxz:) - ddy(:rhow:*:v: - :tauyz:) - ddz(:rhow:*:w: - :tauzz:) ddt(:Et:) = -ddx( (:Et: - :tauxx:)*:u: - :tauxy:*:v: - :tauxz:*:w: ) - ddy( (:Et: - :tauyy:)*:v: -:tauxy:*:u: - :tauyz:*:w:) - ddz( (:Et: - :tauzz:)*:w: - :tauxz:*:u: - :tauyz:*:v: ) # Conservative filter of the EoM :rhoYh: = fbar( :rhoYh: ) :rhoYl: = fbar( :rhoYl: )
problem = 'sod' Lp = L * (Npts - 1.0) / Npts mesh_options = {} mesh_options['coordsys'] = 0 mesh_options['periodic'] = numpy.array([False, False, True]) mesh_options['dim'] = 3 mesh_options['x1'] = [0.0, 0.0, 0.0] mesh_options['xn'] = [Lp, Lp, Lp] mesh_options['nn'] = [Npts, 1, 1] if dim == 2: mesh_options['nn'] = [Npts, Npts, 1] # Initialize a simulation object on a mesh ss = pyrandaSim('advection', mesh_options) ss.addPackage(pyrandaBC(ss)) # Define the equations of motion eom = """ # Primary Equations of motion here ddt(:rho:) = -ddx(:rho:*:u:) - ddy(:rho:*:v:) ddt(:rhou:) = -ddx(:rhou:*:u: + :p: - :tau:) - ddy(:rhou:*:v:) ddt(:rhov:) = -ddx(:rhov:*:u:) - ddy(:rhov:*:v: + :p: - :tau:) ddt(:Et:) = -ddx( (:Et: + :p: - :tau:)*:u: ) - ddy( (:Et: + :p: - :tau:)*:v: ) # Conservative filter of the EoM :rho: = fbar( :rho: ) :rhou: = fbar( :rhou: ) :rhov: = fbar( :rhov: ) :Et: = fbar( :Et: ) # Update the primatives and enforce the EOS
except: testName = None ## Define a mesh L = 1.0 Re = 100.0 mesh_options = {} mesh_options['coordsys'] = 0 mesh_options['periodic'] = numpy.array([False, False, True]) mesh_options['x1'] = [0.0, 0.0, 0.0] mesh_options['xn'] = [L, L, L] mesh_options['nn'] = [Npts, Npts, 1] # Initialize a simulation object on a mesh pysim = pyrandaSim('lidDrivenCavity', mesh_options) pysim.addPackage(pyrandaBC(pysim)) pysim.addPackage(pyrandaTimestep(pysim)) eom = """ # Primary Equations of motion here :us: = :u: + :dt: * ( - :u: * ddx( :u: ) - :v: * ddy( :u: ) + lap(:u:)*:nu: ) :vs: = :v: + :dt: * ( - :u: * ddx( :v: ) - :v: * ddy( :v: ) + lap(:v:)*:nu: ) Delta(:ps:) = 1.0/:dt: * ( ddx(:us:) + ddy(:vs:) ) :u: = :us: - :dt: * ddx(:ps:) :v: = :vs: - :dt: * ddy(:ps:) :u: = fbar(:u:) :v: = fbar(:v:) # Boundary conditions bc.const(['u','v'],['x1','xn','y1'],0.0) bc.const(['u'],['yn'],1.0)
except: test = False ## Define a mesh L = numpy.pi * 2.0 # Define the domain/mesh imesh = """ Lp = %s Npts = %d xdom = (0.0, Lp, Npts, periodic=False) ydom = (0.0, Lp, Npts, periodic=False) """ % (L, Npts) # Initialize a simulation object on a mesh ss = pyrandaSim('Poisson', imesh) # Define the equations of motion eom = """ :wx: = meshx * ( 2.0 * pi - meshx ) :wy: = meshy * ( 2.0 * pi - meshy ) :phi: = cos( meshx ) * :wy: + cos( meshy ) * :wx: Delta(:ff:) = :phi: :gg: = lap(:ff:) """ ss.EOM(eom) # Perform the solve at update ss.updateVars() if not test:
except: test = False ## Define a mesh L = numpy.pi * 2.0 Lp = L * (Npts - 1.0) / Npts # Define the domain/mesh imesh = """ Lp = %s Npts = %d xdom = (0.0, Lp, Npts, periodic=True) """ % (Lp, Npts) # Initialize a simulation object on a mesh ss = pyrandaSim('advection', imesh) # Define the equations of motion ss.EOM(" ddt(:phi:) = -:c: * ddx(:phi:) ") # Initialize variables ic = """ r = sqrt( (meshx-pi)**2 ) :phi: = 1.0 + 0.1 * exp( -(r/(pi/4.0))**2 ) :phi2: = 1.0*:phi: :c: = 1.0 """ ss.setIC(ic) #ss.variables["u"].data += 1.0
ERROR = 0.0 ############################## ######## DERIVATIVES ######## ############################## # Define the domain/mesh Nx = 32 L = numpy.pi * 2.0 * (Nx - 1) / Nx domain = """ xdom = (0.0 , L , Nx ,periodic=True) ydom = (0.0 , L , Nx ,periodic=True) zdom = (0.0 , L , Nx ,periodic=True) """.replace('L', str(L)).replace('Nx', str(Nx)) # Periodic function in X-Y-Z pysim = pyrandaSim('advection', domain) expr = "sum( abs( ddx( sin(meshx) ) - cos(meshx) ))" errorX = pysim.eval(expr) errorY = pysim.eval(expr.replace('x', 'y')) errorZ = pysim.eval(expr.replace('x', 'z')) ERROR += errorX + errorY + errorZ print('Error X = %s' % errorX) print('Error Y = %s' % errorY) print('Error Z = %s' % errorZ) # Non-periodic case domain = """ xdom = (0.0 , 1.0 , Nx ) ydom = (0.0 , 1.0 , Nx )
z = 0.0 return x,y,z mesh_options = {} mesh_options['coordsys'] = 3 mesh_options['function'] = zoomMesh mesh_options['periodic'] = numpy.array([False, False, True]) mesh_options['gridPeriodic'] = numpy.array([False, False, False]) mesh_options['dim'] = 3 mesh_options['x1'] = [ -2*Lp , -2*Lp , 0.0 ] mesh_options['xn'] = [ 2*Lp , 2*Lp , Lp ] mesh_options['nn'] = [ Npts, Npts , 1 ] # Initialize a simulation object on a mesh ss = pyrandaSim(problem,mesh_options) ss.addPackage( pyrandaBC(ss) ) ss.addPackage( pyrandaIBM(ss) ) ss.addPackage( pyrandaTimestep(ss) ) rho0 = 1.0 p0 = 1.0 gamma = 1.4 mach = 2.0 s0 = numpy.sqrt( p0 / rho0 * gamma ) u0 = s0 * mach e0 = p0/(gamma-1.0) + rho0*.5*u0*u0 # Define the equations of motion
from matplotlib import cm from pyranda import pyrandaSim, pyrandaBC from pyranda.pyranda import pyrandaRestart ## Define a mesh L = numpy.pi * 2.0 Npts = 200 Lp = L * (Npts - 1.0) / Npts imesh = """ xdom = (0.0, Lp, Npts) """.replace('Lp', str(Lp)).replace('Npts', str(Npts)) # Initialize a simulation object on a mesh ss = pyrandaSim('sod', imesh) ss.addPackage(pyrandaBC(ss)) # Define the equations of motion eom = """ # Primary Equations of motion here ddt(:rho:) = -ddx(:rho:*:u:) ddt(:rhou:) = -ddx(:rhou:*:u: + :p: - :tau:) ddt(:Et:) = -ddx( (:Et: + :p: - :tau:)*:u: ) # Conservative filter of the EoM :rho: = fbar( :rho: ) :rhou: = fbar( :rhou: ) :Et: = fbar( :Et: ) # Update the primatives and enforce the EOS :u: = :rhou: / :rho: :p: = ( :Et: - .5*:rho:*(:u:*:u:) ) * ( :gamma: - 1.0 )
# Produced at the Lawrence Livermore National Laboratory. # # LLNL-CODE-749864 # This file is part of pyranda # For details about use and distribution, please read: pyranda/LICENSE # # Written by: Britton J. Olson, [email protected] ################################################################################ from pyranda import pyrandaSim # Define the domain/mesh domain = "xdom = (0.0 , 1.0 , 100 )" # Initialize a simulation object on a mesh pysim = pyrandaSim('advection', domain) # Define the equations of motion pysim.EOM("ddt(:phi:) = - ddx(:phi:)") # Initialize variables pysim.setIC(":phi: = 1.0 + 0.1 * exp( -(abs(meshx-.5)/.1 )**2 )") # Integrate in time dt = .001 time = 0.0 while time < .1: time = pysim.rk4(time, dt) # Plot solution pysim.plot.plot('phi')
test = False ## Define a mesh L = numpy.pi * 2.0 Lp = L * (Npts - 1.0) / Npts mesh_options = {} mesh_options['coordsys'] = 0 mesh_options['periodic'] = numpy.array([False, True, True]) mesh_options['dim'] = 1 mesh_options['x1'] = [0.0, 0.0, 0.0] mesh_options['xn'] = [Lp, Lp, Lp] mesh_options['nn'] = [Npts, 1, 1] # Initialize a simulation object on a mesh ss = pyrandaSim('heat_equation', mesh_options) ss.addPackage(pyrandaBC(ss)) # Define the equations of motion eom = """ # Heat equation ddt(:phi:) = :c: * lap(:phi:) # Boundary condition bc.const(['phi'],['x1'],2.0) bc.const(['phi'],['xn'],1.0) """ ss.EOM(eom) # Initialize variables ic = """
# LLNL-CODE-749864 # This file is part of pyranda # For details about use and distribution, please read: pyranda/LICENSE # # Written by: Britton J. Olson, [email protected] ################################################################################ from pyranda import pyrandaSim, pyrandaBC from numpy import pi # Domain is specified with a "mesh dictionary" mesh_options = {} mesh_options['x1'] = [0.0, 0.0, 0.0] mesh_options['xn'] = [2.0 * pi, 2.0 * pi, 1.0] mesh_options['nn'] = [64, 64, 1] ss = pyrandaSim('sod', mesh_options) ss.addPackage(pyrandaBC(ss)) # Define the equations of motion eom = """ # Primary Equations of motion here ddt(:rho:) = -ddx(:rho:*:u:) - ddy(:rho:*:v:) ddt(:rhou:) = -ddx(:rhou:*:u: + :p: - :tau:) - ddy(:rhou:*:v:) ddt(:rhov:) = -ddx(:rhov:*:u:) - ddy(:rhov:*:v: + :p: - :tau:) ddt(:Et:) = -ddx( (:Et: + :p: - :tau:)*:u: ) - ddy( (:Et: + :p: - :tau:)*:v: ) # Conservative filter of the EoM :rho: = fbar( :rho: ) :rhou: = fbar( :rhou: ) :rhov: = fbar( :rhov: ) :Et: = fbar( :Et: )
################################################################################ # Copyright (c) 2018, Lawrence Livemore National Security, LLC. # Produced at the Lawrence Livermore National Laboratory. # # LLNL-CODE-749864 # This file is part of pyranda # For details about use and distribution, please read: pyranda/LICENSE # # Written by: Britton J. Olson, [email protected] ################################################################################ from pyranda import pyrandaSim, pyrandaBC ss = pyrandaSim('sod', 'xdom=(0.0,6.0,200)') ss.addPackage(pyrandaBC(ss)) # Define the equations of motion eom = """ # Primary Equations of motion here ddt(:rho:) = -ddx(:rho:*:u:) ddt(:rhou:) = -ddx(:rhou:*:u: + :p: - :tau:) ddt(:Et:) = -ddx( (:Et: + :p: - :tau:)*:u: ) # Conservative filter of the EoM :rho: = fbar( :rho: ) :rhou: = fbar( :rhou: ) :Et: = fbar( :Et: ) # Update the primatives and enforce the EOS :u: = :rhou: / :rho: :p: = ( :Et: - .5*:rho:*(:u:*:u:) ) * ( :gamma: - 1.0 ) # Artificial bulk viscosity (old school way)
# Try to get args try: Npts = int(sys.argv[1]) except: Npts = 10 try: test = bool(int(sys.argv[2])) except: test = False # Define the domain/mesh domain = "xdom = (0.0 , 1.0 , 1 )" # Initialize a simulation object on a mesh pysim = pyrandaSim('integralTests', domain) # Define the equations of motion eom = """ ddt(:a:) = :a: ddt(:b:) = cos( 6.0*simtime ) """ pysim.EOM(eom) # Initialize variables a0 = 1.0 b0 = 0.0 ic = """ :a: = %s :b: = %s """ % (a0, b0)
def getShu(Npts, viz=False): L = 10.0 Lp = L * (Npts - 1.0) / Npts imesh = "xdom = (-Lp/2.0, Lp/2.0, Npts)" imesh = imesh.replace('Lp', str(Lp)) imesh = imesh.replace('Npts', str(Npts)) # Initialize a simulation object on a mesh ss = pyrandaSim('sod', imesh) ss.addPackage(pyrandaBC(ss)) ss.addPackage(pyrandaTimestep(ss)) # Define the equations of motion from equation_library import euler_1d eom = euler_1d eom += """ # Apply constant BCs bc.const(['u'],['xn'],0.0) bc.const(['u'],['x1'],2.629369) bc.const(['rho'],['x1'],3.857143) bc.const(['p'],['x1'],10.33333) bc.const(['Et'],['x1'],39.166585) :rhou: = :rho:*:u: :cs: = sqrt( :p: / :rho: * :gamma: ) :dt: = dt.courant(:u:,0.0,0.0,:cs:) :dt: = numpy.minimum(:dt:,0.2 * dt.diff(:beta:,:rho:)) """ # Add the EOM to the solver ss.EOM(eom) # Initial conditions Shu-Osher test problem ic = """ :gamma: = 1.4 eps = 2.0e-1 :tmp: = (meshx+4.0)/%s :dum: = tanh(:tmp:) :dum: = (:dum:+1.0)/2.0 :rho: = 3.857143 + :dum:*(1.0+eps*sin(5.0*meshx) - 3.857143) :u: = 2.629369*(1.0-:dum:) :p: = 10.33333 + :dum:*(1.0-10.33333) :rhou: = :rho: * :u: :Et: = :p:/(:gamma: -1.0) + .5*:rho:*:u:*:u: """ # Set the initial conditions ss.setIC(ic % ss.dx) # Write a time loop time = 0.0 # Approx a max dt and stopping time CFL = 0.5 dt = ss.variables['dt'].data * CFL * .01 # Mesh for viz on master x = ss.mesh.coords[0].data xx = ss.PyMPI.zbar(x) # Start time loop cnt = 1 viz_freq = 50 pvar = 'rho' #viz = True tt = 1.8 while tt > time: # Update the EOM and get next dt time = ss.rk4(time, dt) dt = min(dt * 1.1, ss.variables['dt'].data * CFL) dt = min(dt, (tt - time)) # Print some output ss.iprint("%s -- %s" % (cnt, time)) cnt += 1 v = ss.PyMPI.zbar(ss.variables[pvar].data) if viz: if (ss.PyMPI.master and (cnt % viz_freq == 0)) and True: #raw_input('Poop') plt.figure(1) plt.clf() plt.plot(xx[:, 0], v[:, 0], 'k.-') plt.title(pvar) plt.pause(.001) return [ss, xx[:, 0], v[:, 0]]
y1 += yw if y1 > py_max: y1 = 0 ## Define a mesh L = numpy.pi * 2.0 Npts = 200 Lp = L * (Npts - 1.0) / Npts imesh = """ xdom = (0.0, Lp, Npts) """.replace('Lp', str(Lp)).replace('Npts', str(Npts)) # Initialize a simulation object on a mesh ss = pyrandaSim('sodMM', imesh) ss.addPackage(pyrandaBC(ss)) ss.addPackage(pyrandaIBM(ss)) deltaPhi = 2.0 * L / float(Npts) # Define the equations of motion eom = """ # Primary Equations of motion here ddt(:rhoA:) = -ddx(:rhoA:*:uA:) ddt(:rhoB:) = -ddx(:rhoB:*:uB:) ddt(:rhouA:) = -ddx(:rhouA:*:uA: + :pA: - :tauA:) - :FA: ddt(:rhouB:) = -ddx(:rhouB:*:uB: + :pB: - :tauB:) - :FB: ddt(:EtA:) = -ddx( (:EtA: + :pA: - :tauA:)*:uA: ) - :FA:*:uA: ddt(:EtB:) = -ddx( (:EtB: + :pB: - :tauB:)*:uB: ) - :FB:*:uB: ddt(:phi:) = -:gx:*:uphi: - .1 * sign(:phi:)*(:mgp:-1.0) * deltaPhi / (deltat+1.0e-10) #ddt(:uphi:) = -ddx( :uphi:*:uphi: - :tauphi:) - :Fphi:/(:rhoA: + :rhoB:)
y = (j - 1) * dx - .5 * numpy.sin(i / float(Npts) * 2.0 * numpy.pi) z = 0.0 return x, y, z imesh = {} imesh['x1'] = [0.0, 0.0, 0.0] imesh['xn'] = [Lp, Lp, 1] imesh['nn'] = [Npts, Npts, 1] imesh['periodic'] = numpy.array([True, True, True]) imesh['coordsys'] = 3 imesh['dim'] = 3 imesh['function'] = myMesh ss = pyrandaSim('curved_advection', imesh) eom = """ ddt(:phi:) = -div( :phi: * :u: , :phi:*:v: ) """ ss.EOM(eom) ic = """ r = sqrt( (meshx-pi)**2 + (meshy-pi)**2 ) :u: = 1.0 :v: = 0.0 :phi: = 1.0 + 0.1 * exp( -(r/(pi/4.0))**2 ) """ # Set the initial conditions