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
