def general_test(test_func, py0, py1): # Parameters Cx = 0 Cy = 0 Lx = 2 * np.pi Ly = np.pi Nx = 16 Ny = 16 # Bases and domain x_basis = de.Fourier('x', Nx, [Cx, Cx + Lx], dealias=3 / 2) y0_basis = de.SinCos('y0', Ny, [Cy, Cy + Ly], dealias=3 / 2) y1_basis = de.SinCos('y1', Ny, [Cy, Cy + Ly], dealias=3 / 2) domain = de.Domain([x_basis, y0_basis, y1_basis], grid_dtype=np.float64) # Test fields x, y0, y1 = domain.grids() a = Cy - Ly / 2 interp = de.operators.parseables['interp'] f = domain.new_field() f.meta['y0']['parity'] = py0 f.meta['y1']['parity'] = py1 h = domain.new_field() h.meta['y0']['parity'] = 1 h.meta['y1']['parity'] = py0 * py1 f['g'] = test_func(x, y0, y1) h['g'] = test_func(x, y1, y1) g = Diag(f, 'y0', 'y1').evaluate() return np.allclose(g['c'], h['c'])
def domain_from_file(filename, basis_types, dealias=3 / 2): with h5py.File(filename, 'r') as dfile: testkey = next(iter(dfile['tasks'])) testdata = dfile['tasks'][testkey] dims = testdata.shape[1:] # trim write dimension dim_names = [ i.decode('utf-8') for i in testdata.attrs['DIMENSION_LABELS'][1:] ] if not testdata.attrs['grid_space'][-1]: dims[-1] *= 2 bases = [] for n, b, d in zip(dim_names, basis_types, dims): if b == 'Fourier': limits = limits_from_grid('Fourier', dfile['/scales/' + n + '/1.0']) basis = de.Fourier(n, d, interval=limits, dealias=dealias) elif b == 'SinCos': limits = limits_from_grid('SinCos', dfile['/scales/' + n + '/1.0']) basis = de.SinCos(n, d, interval=limits, dealias=dealias) elif b == 'Chebyshev': limits = (-1, 1) # limits not implemented for Chebyshev basis = de.Chebyshev(n, d, limits=limits, dealias=dealias) else: raise ValueError("Unknown basis type:", basis_type) bases.append(basis) d = de.Domain(bases, grid_dtype=np.float64) # hardcoded domain dtype for now return d
def build_solver(nx, ny, Lx, Ly, RA, BE, PR, CC): comm = MPI.COMM_WORLD rank = comm.Get_rank() Nx = nx Ny = ny #for equilibrium: # C = 0, beta = 0, Pr = 1, Ra = 5000 Ra = RA Pr = PR beta = BE C = CC #for travelling wave #Ra = 7.542e5 Pr = 1. beta = 3E4 C = 0 if rank == 0: print("dedalus: solver is built for: Nx "+str(nx)+" Ny: "+str(ny)+" Lx: "+str(Lx)+ " Ly: "+str(Ly)+" and Ra: "+str(Ra)) print("dedalus: Pr "+str(Pr)+" beta: "+str(beta)+" C: "+str(C)) x_basis = de.Fourier('x', Nx, interval=(0, Lx), dealias=3/2) y_basis = de.SinCos ('y', Ny, interval=(0, Ly), dealias=3/2) domain = de.Domain([x_basis, y_basis], grid_dtype=np.float64) # 2D Boussinesq hydrodynamics problem = de.IVP(domain, variables=['psi','theta','zeta'], time='t') problem.meta['psi','zeta','theta']['y']['parity'] = -1 # sin basis problem.parameters['Pr'] = Pr problem.parameters['Ra'] = Ra problem.parameters['beta'] = beta problem.parameters['sbeta'] = np.sqrt(np.abs(beta)) problem.parameters['C'] = C # construct the 2D Jacobian problem.substitutions['J(A,B)'] = "dx(A) * dy(B) - dy(A) * dx(B)" problem.add_equation("dt(zeta) - beta*dx(psi) + Ra/Pr * dx(theta) + C * sbeta * zeta - dx(dx(zeta)) - dy(dy(zeta)) = -J(psi,zeta)", condition="ny != 0") problem.add_equation("dt(theta) + dx(psi) - (dx(dx(theta)) + dy(dy(theta)))/Pr = -J(psi,theta)", condition="ny != 0") problem.add_equation("dx(dx(psi)) + dy(dy(psi)) - zeta = 0", condition="ny != 0") problem.add_equation("zeta = 0", condition="ny ==0") problem.add_equation("theta = 0", condition="ny ==0") problem.add_equation("psi = 0", condition="ny ==0") # Build solver solver = problem.build_solver(de.timesteppers.MCNAB2) #solver = problem.build_solver(de.timesteppers.SBDF1) logger.info('Solver built') return solver
r = 1 length = 10 # for 3D runs, you can divide the work up over two dimensions (x and y). # The product of the two elements of mesh *must* equal the number # of cores used. # mesh = None mesh = [14,12] kappa = 0.01 mu = 0.01 eta = 0.001 rho0 = 1 gamma = 5./3. x = de.SinCos('x', nx, interval=(-r, r)) y = de.SinCos('y', ny, interval=(-r, r)) z = de.SinCos('z', nz, interval=(0,length)) domain = de.Domain([x,y,z],grid_dtype='float', mesh=mesh) SSX = de.IVP(domain, variables=['lnrho','T', 'vx', 'vy', 'vz', 'Ax', 'Ay', 'Az', 'phi']) ######################################################################################################### """ Meta Parameters """ ######################################################################################################### SSX.meta['T','lnrho']['x', 'y', 'z']['parity'] = 1 SSX.meta['phi']['x', 'y', 'z']['parity'] = -1 SSX.meta['vx']['y', 'z']['parity'] = 1 SSX.meta['vx']['x']['parity'] = -1 SSX.meta['vy']['x', 'z']['parity'] = 1
Lx = 1. Lz = 2. # # This Nx and Nz is for the 'new' or alternative grid (in this case Dedalus) # NxAlt = 8 NzAlt = 12 # Bases and domain for Dedalus xBasis = de.Fourier('x', NxAlt, interval=(0., Lx), dealias=3/2) zBasis = de.SinCos('z', NzAlt, interval=(0, Lz), dealias=3/2) domain = de.Domain([xBasis, zBasis], grid_dtype=np.float64) xgridAlt = domain.grid(0) zgridAlt = domain.grid(1) # # We define a function here so that we can use it to check our interpolation # later # uWaveDedalus = domain.new_field(name='uWaveDedalus') uWaveDedalus.meta['z']['parity'] = -1 uWaveDedalusInterp = domain.new_field(name='uWaveDedalus') uWaveDedalusInterp.meta['z']['parity'] = -1
pi = np.pi Px, Py, Pz = (params['px'], params['py'], params['pz']) Nx, Ny = (params['nx'], params['nx']) Nz = params['nz'] Lx, Ly = (params['lx'] * params['lc'], params['lx'] * params['lc']) Lz = 1.0 Axy = Lx * Ly Ra = params['ra'] Pr = params['pr'] logger.info('Parameters loaded for case: %s' % (params['case'])) x_basis = de.Fourier('x', Nx, interval=(0.0, Lx), dealias=3 / 2) y_basis = de.Fourier('y', Ny, interval=(0.0, Ly), dealias=3 / 2) z_basis = de.SinCos('z', Nz, interval=(0.0, Lz), dealias=3 / 2) domain = de.Domain([x_basis, y_basis, z_basis], grid_dtype=np.float64, mesh=[Px, Py, Pz]) variables = ['tf', 'w', 'si', 'u', 'v', 'ze'] problem = de.IVP(domain, variables=variables, time='t') problem.meta['si']['z']['parity'] = +1 problem.meta['w']['z']['parity'] = -1 problem.meta['tf']['z']['parity'] = -1 # problem.meta['tz']['z']['parity'] = +1 problem.meta['u']['z']['parity'] = +1 problem.meta['v']['z']['parity'] = +1 problem.meta['ze']['z']['parity'] = +1 problem.parameters['Ra'] = Ra problem.parameters['Axy'] = Axy
logger.info("Running with Nx = {:d}, Ny = {:d}".format(param.Nx, param.Ny)) logger.info("Ra = {:e}".format(param.Ra)) logger.info("beta = {:e}".format(param.beta)) logger.info("Pr = {:e}".format(param.Pr)) logger.info("C = {:e}".format(param.C)) logger.info("cu_lambda = {:e}".format(param.cu_lambda)) logger.info("cu_ampl = {:e}".format(param.cu_ampl)) if param.force_symmetry: logger.info("enforcing symmetry every {:d} timesteps".format( param.force_symmetry)) # Bases and domain x_basis = de.Fourier('x', param.Nx, [-param.Lx / 2, param.Lx / 2], dealias=3 / 2) y0_basis = de.SinCos('y0', param.Ny, [0, param.Ly], dealias=3 / 2) y1_basis = de.SinCos('y1', param.Ny, [0, param.Ly], dealias=3 / 2) domain = de.Domain([x_basis, y0_basis, y1_basis], grid_dtype=np.float64, mesh=param.mesh) x, y0, y1 = domain.grids() # Problem problem = de.IVP(domain, variables=['cs', 'css', 'ct', 'cts', 'cst', 'ctt']) problem.meta['cs']['x']['constant'] = True problem.meta['ct']['x']['constant'] = True problem.meta['cs']['y0']['parity'] = 1 problem.meta['ct']['y0']['parity'] = 1 problem.meta['cs']['y1']['parity'] = -1
from dedalus import public as de from dedalus.extras import flow_tools import logging logger = logging.getLogger(__name__) # Parameters Lx, Ly, Lz = (1, 1, 2.) Prandtl = 1. Reynolds = 1e3 N = 256 # Create bases and domain x_basis = de.SinCos('x', N, interval=(-Lx / 2, Lx / 2), dealias=3 / 2) y_basis = de.SinCos('y', N, interval=(-Ly / 2, Ly / 2), dealias=3 / 2) z_basis = de.SinCos('z', 2 * N, interval=(0, Lz), dealias=3 / 2) domain = de.Domain([x_basis, y_basis, z_basis], grid_dtype=np.float64, mesh=[64, 32]) x = domain.grid(0) y = domain.grid(1) z = domain.grid(2) # 2D Boussinesq hydrodynamics problem = de.IVP(domain, variables=['p', 'rho', 'u', 'v', 'w', 'rhoz', 'uz', 'vz']) problem.meta['p', 'rhoz']['x', 'y', 'z']['parity'] = 1
import matplotlib.pyplot as plt import numpy as np import dedalus.public as de from dedalus.tools.array import axslice, reshape_vector from dedalus.core.evaluator import Evaluator import diagonal nx = 8 ny = 16 x = de.Fourier('x', nx) y0 = de.SinCos('y0', ny) y1 = de.SinCos('y1', ny) dom = de.Domain([x, y0, y1], grid_dtype='float', mesh=[2, 2]) data = dom.new_field() data.meta['y1']['parity'] = -1 data.meta['y0']['parity'] = -1 xx, yy0, yy1 = dom.grids() data['g'] = (1 + np.cos(xx) + np.cos(2 * xx)) * ( np.sin(yy0) * np.sin(2 * yy1) + 10 * np.sin(yy0) * np.sin(yy1)) op = diagonal.CoefficientDiagonal(data, 'y0', 'y1') out = op.evaluate() data = Evaluator(dom, vars={'out': out}) output = data.add_file_handler("test_data", max_writes=1)
restart_dirs.sort() last = int(re.search("_restart(\d+)", restart_dirs[-1]).group(1)) data_dir += "_restart{}".format(last + 1) else: if os.path.exists(data_dir): data_dir += "_restart1" if MPI.COMM_WORLD.rank == 0: if not os.path.exists('{:s}/'.format(data_dir)): os.mkdir('{:s}/'.format(data_dir)) # Create bases and domain start_init_time = time.time() x_basis = de.Fourier('x', nx, interval=(0, Lx), dealias=3 / 2) y_basis = de.SinCos('y', ny, interval=(0, Ly), dealias=3 / 2) if xy: bases = [x_basis, y_basis] else: bases = [y_basis, x_basis] domain = de.Domain(bases, grid_dtype=np.float64) # 2D Boussinesq hydrodynamics problem = de.IVP(domain, variables=['psi', 'theta'], time='t') problem.meta['psi', 'theta']['y']['parity'] = -1 # sin basis problem.parameters['Pr'] = Pr problem.parameters['Ra'] = Ra problem.parameters['beta'] = beta problem.parameters['sbeta'] = np.sqrt(np.abs(beta)) problem.parameters['C'] = C
data = {'r':r,'z':z,'vz':vz,'t':t} pickle.dump(data,open("velocity_flux.pkl",'wb')) if rank == 0: print('loading velocity') data = pickle.load(open("velocity_flux.pkl",'rb')) r = data['r'] z = data['z'] vz = data['vz'] t = data['t'] # 5. calculate psi=0 == control volume if rank == 0: r_basis_old = de.SinCos('r', 256, interval=(0, np.max(r))) z_basis_old = de.SinCos('z', 1024, interval=(0, 2)) domain_old = de.Domain([r_basis_old,z_basis_old], grid_dtype=np.float64, comm=MPI.COMM_SELF) r_old = domain_old.grid(0) w_old = domain_old.new_field() w_old.meta['r']['parity'] = 1 w_old.meta['z']['parity'] = -1 problem_old = de.LBVP(domain_old, variables=['psi']) problem_old.parameters['w'] = w_old z_basis = de.SinCos('z', 1024, interval=(0, 2)) r_basis = de.Chebyshev('r', 256, interval=(0, np.max(r))) domain = de.Domain([z_basis,r_basis], grid_dtype=np.float64, comm=MPI.COMM_SELF)
Nx = theta.domain.bases[0].grid_size(scale=1) Ny = theta.domain.bases[1].grid_size(scale=1) print(args['--xres']) if args['--xres'] == 'None': output_Nx = Nx else: output_Nx = int(args['--xres']) if args['--yres'] == 'None': output_Ny = Ny else: output_Ny = int(args['--yres']) x_basis = de.Fourier('x', Nx, [-Lx/2, Lx/2]) y0_basis = de.SinCos('y0', Ny, [0, Ly]) y1_basis = de.SinCos('y1', Ny, [0, Ly]) domain = de.Domain([x_basis, y0_basis, y1_basis], grid_dtype=np.float64) xi, y0, y1 = domain.grids() out_fields = ['cs','ct', 'css', 'ctt', 'cts', 'cst'] y0_parity = [1, 1, -1, -1, -1, -1] output_vars = {} for name, parity in zip(out_fields, y0_parity): output_vars[name] =domain.new_field(name=name) output_vars[name].meta['y0']['parity'] = parity output_vars[name].meta['y1']['parity'] = -1 output_vars['ct'].meta['x']['constant'] = True
# of cores used. #mesh = None mesh = [14, 12] # Introducing Parameters params = runconfig['params'] kappa = params.getfloat('kappa') # kappa is heat conductivity mu = params.getfloat('mu') # mu is viscosity eta = params.getfloat('eta') # eta is resistivity rho0 = params.getfloat('rho0') gamma = params.getfloat('gamma') # gamma is the adiabatic constant #eta_sp = 2.7 * 10**(-4) #Not currently being used #eta_ch = 4.4 * 10**(-3) #v0_ch = 2.9 * 10**(-2) x = de.SinCos('x', nx, interval=(-r, r), dealias=3 / 2) y = de.SinCos('y', ny, interval=(-r, r), dealias=3 / 2) z = de.SinCos('z', nz, interval=(0, length), dealias=3 / 2) domain = de.Domain([x, y, z], grid_dtype='float', mesh=mesh) SSX = de.IVP( domain, variables=['lnrho', 'T', 'vx', 'vy', 'vz', 'Ax', 'Ay', 'Az', 'phi']) SSX.meta['T', 'lnrho']['x', 'y', 'z']['parity'] = 1 #SSX.meta['eta1']['x', 'y', 'z']['parity'] = 1 SSX.meta['phi']['x', 'y', 'z']['parity'] = -1 SSX.meta['vx']['y', 'z']['parity'] = 1 SSX.meta['vx']['x']['parity'] = -1
data = {'r': r, 'z': z, 'vz': vz, 't': t} pickle.dump(data, open("velocity_flux.pkl", 'wb')) if rank == 0: print('loading velocity') data = pickle.load(open("velocity_flux.pkl", 'rb')) r = data['r'] z = data['z'] vz = data['vz'] t = data['t'] # 5. calculate psi=0 == control volume if rank == 0: r_basis_old = de.SinCos('r', int(N / 4), interval=(0, np.max(r))) z_basis_old = de.SinCos('z', N, interval=(0, 2)) domain_old = de.Domain([r_basis_old, z_basis_old], grid_dtype=np.float64, comm=MPI.COMM_SELF) r_old = domain_old.grid(0) w_old = domain_old.new_field() w_old.meta['r']['parity'] = 1 w_old.meta['z']['parity'] = -1 problem_old = de.LBVP(domain_old, variables=['psi']) problem_old.parameters['w'] = w_old z_basis = de.SinCos('z', N, interval=(0, 2))
# Save parameters Nx, Nz = 2048, 1024 dt = 5e-4 sim_name = sys.argv[1] restart = int(sys.argv[2]) steps = 1000000 save_freq = 1000 save_max = 20 print_freq = 200 wall_time = 23 * 60 * 60 save_dir = '.' # Domain xbasis = de.Fourier('x', Nx, interval=(0, L), dealias=3 / 2) zbasis = de.SinCos('z', Nz, interval=(0, H), dealias=3 / 2) domain = de.Domain([xbasis, zbasis], grid_dtype=np.float64) x, z = domain.grids(domain.dealias) xx, zz = x + 0 * z, 0 * x + z kx, kz = domain.elements(0), domain.elements(1) # Wall penalty boundary wall = domain.new_field() wall.set_scales(domain.dealias) wall.meta['z']['parity'] = 1 #wall['g'] = sigmoid(-(x-0.02*L),a=2*ε)+sigmoid(x-.98*L,a=2*ε) # wall['g'] = 0 # no wall wall['c'] *= np.exp(-kx**2 / 5e6) # spectral smoothing # Seawater equation of state Buoyancy funtion from dedalus.core.operators import GeneralFunction
def set_up_coarse(self): """ Make a solver very similar to an existing solver""" eq_list, param_list, base_list = self.get_solver_details( self.fine_solver) self.base_list = base_list coarse_bases = [] for i in range(len(base_list)): base_type = base_list[i]['base_type'] coarse_res = np.rint(base_list[i]['N'] * (1 / (self.ratio))).astype(int) if base_type == 'Fourier': base = de.Fourier(base_list[i]['name'], coarse_res, interval=base_list[i]['interval'], dealias=base_list[i]['dealias']) coarse_bases.append(base) elif base_type == 'Chebyshev': coarse_bases.append( de.Chebyshev(base_list[i]['name'], coarse_res, interval=base_list[i]['interval'], dealias=base_list[i]['dealias'])) elif base_type == 'SinCos': coarse_bases.append( de.SinCos(base_list[i]['name'], coarse_res, interval=base_list[i]['interval'], dealias=base_list[i]['dealias'])) domain_coarse = de.Domain(coarse_bases, np.float64, comm=self.x_comm) problem_coarse = de.IVP(domain_coarse, variables=self.communication_fields) # Copy meta values from fine solver for var in self.communication_fields: for base in base_list: base_name = base['name'] meta_keys = self.fine_solver.problem.meta[var][base_name].keys( ) for key in meta_keys: if key in self.fine_solver.problem.meta[var][ base_name].keys(): problem_coarse.meta[var][base_name][key] = \ self.fine_solver.problem.meta[var][base_name][key] for i in range(len(param_list)): problem_coarse.parameters[param_list[i][0]] = param_list[i][1] for i in range(len(eq_list)): problem_coarse.add_equation(eq_list[i]) # for i in range(len(self.fine_solver.problem.bcs)): # bc = self.fine_solver.problem.bcs[i] # bc_condition = self.fine_solver.problem.bcs[i]['raw_condition'] # bc_string = self.fine_solver.problem.bcs[i]['raw_equation'] # problem_coarse.add_bc(bc_string, condition=bc_condition) timestep_type = self.fine_solver.timestepper.__class__.__name__ if timestep_type == "RK443": solver_coarse = problem_coarse.build_solver(de.timesteppers.RK443) elif timestep_type == "RK222": solver_coarse = problem_coarse.build_solver(de.timesteppers.RK222) elif timestep_type == "RK111": solver_coarse = problem_coarse.build_solver(de.timesteppers.RK111) self.coarse_solver = solver_coarse
initial_time = time.time() # Global parameters Nx = 16 Ny = 16 Nz = 16 Prandtl = 0.025 Rayleigh = 10**5 Lx = 25 Ly = 25 Lz = 1 # Create bases and domain #x_basis = de.Fourier('x', Nx, interval=(0, Lx)) #y_basis = de.Fourier('y', Ny, interval=(0, Ly)) x_basis = de.SinCos('x', Nx, interval=(0, Lx / 2)) y_basis = de.SinCos('y', Ny, interval=(0, Ly / 2)) z_basis = de.Chebyshev('z', Nz, interval=(0, Lz)) domain = de.Domain([x_basis, y_basis, z_basis], grid_dtype=np.float64) # 3D Boussinesq #problem = de.IVP(domain, variables=['p','b','u','v','w','by','vy','uy','wy','bz','uz','vz','wz']) problem = de.IVP(domain, variables=['p', 'b', 'u', 'v', 'w', 'bz', 'uz', 'vz', 'wz'], time='t') problem.meta['p', 'b', 'w', 'bz', 'wz']['x', 'y']['parity'] = 1 problem.meta['v', 'vz']['x']['parity'] = 1 problem.meta['v', 'vz']['y']['parity'] = -1 problem.meta['u', 'uz']['x']['parity'] = -1 problem.meta['u', 'uz']['y']['parity'] = 1
import numpy as np import dedalus.public as de from reverse import ReverseFirst import logging logger = logging.getLogger(__name__) de.operators.parseables['RFirst'] = ReverseFirst x = de.Fourier('x', 16, dealias=3 / 2, interval=[-np.pi, np.pi]) y0 = de.SinCos('y0', 32, dealias=3 / 2) y1 = de.SinCos('y1', 32, dealias=3 / 2) domain = de.Domain([x, y0, y1], grid_dtype='float', mesh=[2, 2]) f = domain.new_field() g = domain.new_field() for field in [f, g]: for ax in ['y0', 'y1']: field.meta[ax]['parity'] = -1 xx = domain.grid(0) yy0 = domain.grid(1) yy1 = domain.grid(2) #test_func = lambda xx, yy, zz: np.cos(xx) + np.sin(4*xx) test_func = lambda xx, yy, zz: np.cos(xx) + np.sin(4 * xx) * np.sin(yy0) f['g'] = test_func(xx, yy0, yy1) g['g'] = test_func(-xx, yy0, yy1) g.set_scales(domain.dealias)
def meta_constant(self, axis): # Preserve constancy pass def check_conditions(self): # Shearing layout pass def operate(self, out): pass test = 'fourier' # works #test = 'sin' # fails xi = de.Fourier('xi', 128) if test == 'fourier': y0 = de.Fourier('y0', 128) y1 = de.Fourier('y1', 128) else: y0 = de.SinCos('y0', 128) y1 = de.SinCos('y1', 128) domain = de.Domain([xi, y0,y1],grid_dtype='float') #domain = de.Domain([y0,y1],grid_dtype='float') f = domain.new_field() scd = OpTest(f,'y0','y1') scd.meta
import logging logger = logging.getLogger(__name__) # Parameters Lx, Ly, Lz = (25., 25., 1.) epsilon = 0.8 Pr = 1.0 Ra_crit = 1707.762 # No-slip top & bottom Ra = Ra_crit * (1 + epsilon) # Create bases and domain start_init_time = time.time() x_basis = de.SinCos('x', 64, interval=(0, Lx), dealias=3/2) y_basis = de.SinCos('y', 64, interval=(0, Ly), dealias=3/2) z_basis = de.Chebyshev('z', 16, interval=(-Lz/2, Lz/2), dealias=3/2) domain = de.Domain([x_basis, y_basis, z_basis], grid_dtype=np.float64) # 2D Boussinesq hydrodynamics problem = de.IVP(domain, variables=['p','b','u','v','w','bz','uz','vz','wz'], time='t') problem.meta['p','b','w','bz','wz']['x','y']['parity'] = 1 problem.meta['v','vz']['x']['parity'] = 1 problem.meta['v','vz']['y']['parity'] = -1 problem.meta['u','uz']['x']['parity'] = -1 problem.meta['u','uz']['y']['parity'] = 1 problem.parameters['P'] = 1 problem.parameters['R'] = Pr problem.parameters['F'] = F = Ra*Pr
theta = 1 - np.exp(-Np/m) # Dimensionaless inverse T scale height snapshot_freq = 0.05 # Output frequency of the full data cube analysis_freq = 0.005 # Output frequency of the analysis tasks max_dt = 1e-4 # Maximum allowed timestep # Initial timestep init_dt = 1e-5 # Integration parameters --- Note if these are all set to np.inf, simulation will perpetually run. stop_sim_t = 1 stop_wall_t = np.inf stop_iter = np.inf # Create bases and domain x_basis = de.SinCos('x', Nx, interval=(0, Lx), dealias=3/2) # Fourier basis in the x z_basis = de.Chebyshev('z', Nz, interval=(0, Lz), dealias=3/2) # Chebyshev basis in the z domain = de.Domain([x_basis, z_basis], grid_dtype=np.float64) # Defining our domain z = domain.grid(1, scales=1) # accessing the z values # 2D Anelastic hydrodynamics problem = de.IVP(domain, variables=['p', 's', 'u', 'w', 'sz', 'uz', 'wz', 'L_buoy', 'L_diss']) problem.meta['p','s','u','w']['z']['dirichlet'] = True problem.meta['p','s','w','sz','wz','L_buoy','L_diss']['x']['parity'] = 1 problem.meta['u','uz']['x']['parity'] = -1 # Defining model parameters problem.parameters['Lx'] = Lx problem.parameters['Lz'] = Lz problem.parameters['Ra'] = Ra problem.parameters['Pr'] = Pr