def set_IVP(self, *args, ncc_cutoff=1e-10, **kwargs): """ Constructs and initial value problem of the current object's equation set """ self.problem_type = 'IVP' self.problem = de.IVP(self.domain, variables=self.variables, ncc_cutoff=ncc_cutoff) self.set_equations(*args, **kwargs)
def problem_setup(self, mu=-1): # Problem #variables: flowfield (u,v)(x,y), pressure p(x,y), vorticity w(x,y) self.problem = de.IVP(self.domain, variables=['u', 'v', 'w', 'p']) self.problem.parameters['a'] = mu self.problem.parameters['b'] = 0.5 self.problem.parameters['Tau_0'] = self.T0 self.problem.parameters['Tau_2'] = self.T2 self.problem.parameters['S'] = -2.5 #Incompressibility self.problem.add_equation("dx(u) + dy(v) = 0", condition="(nx!=0) or (ny!=0)") self.problem.add_equation("p = 0", condition="(nx==0) and (ny==0)") #dynamics (-S)*dx(u+v) self.problem.add_equation( "dt(u) + dx(p) + a*u - Tau_0*(d(u,x=2) + d(u,y=2)) + Tau_2*(d(u,x=4) + d(u,y=4)) = \ -(1-S)*(u*dx(u) + v*dy(u)) + (-S/2)*dx(u*u+v*v) - b*(u*u+v*v)*u" ) self.problem.add_equation( "dt(v) + dy(p) + a*v - Tau_0*(d(v,x=2) + d(v,y=2)) + Tau_2*(d(v,x=4) + d(v,y=4)) = \ -(1-S)*(u*dx(v) + v*dy(v)) + (-S/2)*dy(u*u+v*v) - b*(u*u+v*v)*v" ) # self.problem.add_equation("dt(u) + dx(p) + a*u - Tau_0*d(u,x=2) + Tau_2*d(u,x=4) = 0") # self.problem.add_equation("dt(v) + dy(p) + a*v - Tau_0*d(v,y=2) + Tau_2*d(v,y=4) = 0") #vorticity self.problem.add_equation("w - dx(v) + dy(u) = 0")
def build_solver(self): self.problem = de.IVP(self.domain, variables=['u', 'v', 'w', 'uz', 'vz', 'wz', 'p']) self.problem.parameters['Re'] = self.Re self.problem.substitutions['ugrad(A, Az)'] = 'u*dx(A) + v*dy(A) + w*Az' self.problem.substitutions[ 'Lap(A, Az)'] = 'dx(dx(A)) + dy(dy(A)) + dz(Az)' self.problem.add_equation( "dt(u) + dx(p) - Lap(u, uz)/Re + w + z*dx(u) = ugrad(u,uz)") self.problem.add_equation( "dt(v) + dy(p) - Lap(v, vz)/Re + z*dx(v) = ugrad(v,vz)") self.problem.add_equation( "dt(w) + dz(p) - Lap(w, wz)/Re + z*dx(w) = ugrad(w,wz)") self.problem.add_equation("dx(u) + dy(v) + wz = 0") self.problem.add_equation("dz(u) + uz = 0") self.problem.add_equation("dz(v) + vz = 0") self.problem.add_equation("dz(w) + wz = 0") self.problem.add_bc("left(u) = 0") self.problem.add_bc("right(u) = 0") self.problem.add_bc("left(v) = 0") self.problem.add_bc("right(v) = 0") self.problem.add_bc("left(w) = 0") self.problem.add_bc("right(w) = 0", condition="(nx != 0) or (ny != 0)") self.problem.add_bc("left(p) = 0", condition="(nx == 0) and (ny == 0)") self.solver = self.problem.build_solver(de.timesteppers.RK443) logger.info('Solver built')
def serial_run(dt_fine, resolution, end_time): save_name = 'test' # Here we use parareal split function to create two communicators # Fine solver logger = logging.getLogger(__name__) xbasis_serial = de.Fourier('x', resolution, interval=(0, 5), dealias=1) domain_serial = de.Domain([xbasis_serial], grid_dtype=np.float64, comm=dedalus_comm) problem_serial = de.IVP(domain_serial, variables=['u']) problem_serial.parameters['a'] = a problem_serial.parameters['b'] = b problem_serial.add_equation("dt(u) - b*dx(dx(u)) = a*dx(u)") solver_serial = problem_serial.build_solver(de.timesteppers.RK111) # initial conditions x_serial = domain_serial.grid(0) u_serial = solver_serial.state['u'] u_serial.set_scales(1) mu = 2.5 sigma = 2 u_serial['g'] = 100 / (np.sqrt(2 * np.pi * sigma**2)) * np.exp( -(x_serial - mu)**2 / (2 * sigma**2)) for i in range(np.rint(end_time / dt_fine).astype(int)): solver_serial.step(dt_fine) return np.copy(u_serial['g'])
def get_solver(setup_problem, XMAX, ZMAX, N_X, N_Z, T_F, KX, KZ, H, RHO0, G, A): # Bases and domain x_basis = de.Fourier('x', N_X, interval=(0, XMAX), dealias=3 / 2) z_basis = de.Chebyshev('z', N_Z, interval=(0, ZMAX), dealias=3 / 2) domain = de.Domain([x_basis, z_basis], np.float64) z = domain.grid(1) problem = de.IVP(domain, variables=['P', 'rho', 'ux', 'uz']) problem.meta['uz']['z']['dirichlet'] = True problem.parameters['L'] = XMAX problem.parameters['g'] = G problem.parameters['H'] = H problem.parameters['A'] = A problem.parameters['KX'] = KX problem.parameters['KZ'] = KZ problem.parameters['omega'] = get_omega(G, H, KX, KZ) # rho0 stratification rho0 = domain.new_field() rho0.meta['x']['constant'] = True rho0['g'] = RHO0 * np.exp(-z / H) problem.parameters['rho0'] = rho0 setup_problem(problem, domain) # Build solver solver = problem.build_solver(de.timesteppers.RK443) solver.stop_sim_time = T_F solver.stop_wall_time = np.inf solver.stop_iteration = np.inf return solver, domain
def mcwilliams_problem(domain, h=0.1, lx=1 / 4, ly=1 / 8, f=1, US=1 / 16): problem = de.IVP(domain, variables=['ψ', 'ψz']) problem.parameters['h'] = h problem.parameters['lx'] = lx problem.parameters['ly'] = ly problem.parameters['f'] = f problem.parameters['N'] = h / (f * lx) problem.parameters['US'] = 0.5 * f * lx problem.substitutions[ 'uS'] = " US * exp(z/h - x**2 / (2 * lx**2) - y**2 / (2 * ly**2))" problem.substitutions[ 'uSy'] = "- y / ly**2 * US * exp(z/h - x**2 / (2 * lx**2) - y**2 / (2 * ly**2))" problem.substitutions[ 'uSz'] = " 1 / h * US * exp(z/h - x**2 / (2 * lx**2) - y**2 / (2 * ly**2))" problem.add_equation( "dt(ψ) - dx(dx(ψ)) - dy(dy(ψ)) - f**2 / N**2 * dz(ψz) = f * uSz / N**2 * (dy(ψz) + dy(ψ) / h) + uSy", condition="(nx != 0) or (ny != 0)") problem.add_equation("ψ = 0", condition="(nx == 0) and (ny == 0)") problem.add_equation("ψz = 0", condition="(nx == 0) and (ny == 0)") problem.add_equation("dz(ψ) - ψz = 0", condition="(nx != 0) or (ny != 0)") problem.add_bc("right(f * ψz) = right(uSz * dy(ψ))", condition="(nx != 0) or (ny != 0)") problem.add_bc("left(ψz) = 0", condition="(nx != 0) or (ny != 0)") # Build solver solver = problem.build_solver(de.timesteppers.SBDF3) return solver
def test_1d_output(x_basis_class, Nx, timestepper, dtype): # Bases and domain x_basis = x_basis_class('x', Nx, interval=(0, 2 * np.pi)) domain = de.Domain([x_basis], grid_dtype=dtype) # Forcing F = domain.new_field(name='F') x = domain.grid(0) F['g'] = -np.sin(x) # Problem problem = de.IVP(domain, variables=['u', 'ux']) problem.parameters['F'] = F problem.add_equation("ux - dx(u) = 0") problem.add_equation("-dt(u) + dx(ux) = F") problem.add_bc("left(u) - right(u) = 0") problem.add_bc("left(ux) - right(ux) = 0") # Solver solver = problem.build_solver(timestepper) # Output output = solver.evaluator.add_file_handler('test_output', iter=1) output.add_task('u', layout='g', name='ug') # Loop dt = 1e-5 iter = 10 for i in range(iter): solver.step(dt) # Check solution post.merge_process_files('test_output') with h5py.File('test_output/test_output_s1.h5', mode='r') as file: ug = file['tasks']['ug'][:] t = file['scales']['sim_time'][:] shutil.rmtree('test_output') amp = 1 - np.exp(-t[:, None]) u_true = amp * np.sin(x[None, :]) assert np.allclose(ug, u_true)
def test_heat_1d_nonperiodic(benchmark, x_basis_class, Nx, timestepper, dtype): # Bases and domain x_basis = x_basis_class('x', Nx, interval=(0, 2 * np.pi)) domain = de.Domain([x_basis], grid_dtype=dtype) # Forcing F = domain.new_field(name='F') x = domain.grid(0) F['g'] = -np.sin(x) # Problem problem = de.IVP(domain, variables=['u', 'ux']) problem.parameters['F'] = F problem.add_equation("ux - dx(u) = 0") problem.add_equation("-dt(u) + dx(ux) = F") problem.add_bc("left(u) - right(u) = 0") problem.add_bc("left(ux) - right(ux) = 0") # Solver solver = problem.build_solver(timestepper) dt = 1e-5 iter = 10 for i in range(iter): solver.step(dt) # Check solution amp = 1 - np.exp(-solver.sim_time) u_true = amp * np.sin(x) u = solver.state['u'] assert np.allclose(u['g'], u_true)
def get_solver(params): ''' sets up solver ''' x_basis = de.Fourier('x', params['N_X'], interval=(0, params['XMAX']), dealias=3 / 2) z_basis = de.Chebyshev('z', params['N_Z'], interval=(0, params['ZMAX']), dealias=3 / 2) domain = de.Domain([x_basis, z_basis], np.float64) z = domain.grid(1) problem = de.IVP(domain, variables=[ 'P', 'rho', 'ux', 'uz', 'ux_z', 'uz_z', ]) problem.parameters.update(params) # rho0 stratification rho0 = domain.new_field() rho0.meta['x']['constant'] = True rho0['g'] = params['RHO0'] * np.exp(-z / params['H']) problem.parameters['rho0'] = rho0 problem.substitutions['sponge'] = 'SPONGE_STRENGTH * 0.5 * ' +\ '(2 + tanh((z - SPONGE_HIGH) / (0.6 * (ZMAX - SPONGE_HIGH))) - ' +\ 'tanh((z - SPONGE_LOW) / (0.6 * (SPONGE_LOW))))' problem.add_equation('dx(ux) + dz(uz) = 0') problem.add_equation('dt(rho) - rho0 * uz / H' + '= - sponge * rho - ux * dx(rho) - uz * dz(rho) +' + 'F * exp(-(z - Z0)**2 / (2 * S**2)) *' + 'cos(KX * x - OMEGA * t)') problem.add_equation('dt(ux) + dx(P) / rho0' + '- NU * (dx(dx(ux)) + dz(ux_z))' + '= - sponge * ux - ux * dx(ux) - uz * dz(ux)') problem.add_equation('dt(uz) + dz(P) / rho0 + rho * g / rho0' + '- NU * (dx(dx(uz)) + dz(uz_z))' + '= - sponge * uz - ux * dx(uz) - uz * dz(uz)') problem.add_equation('dz(ux) - ux_z = 0') problem.add_equation('dz(uz) - uz_z = 0') problem.add_bc('left(uz) = 0') problem.add_bc('left(ux) = 0') problem.add_bc('right(uz) = 0') problem.add_bc('right(ux) = 0') problem.add_bc('right(P) = 0') # Build solver solver = problem.build_solver(de.timesteppers.RK443) solver.stop_sim_time = params['T_F'] solver.stop_wall_time = np.inf solver.stop_iteration = np.inf return solver, domain
def problem_setup(self): # Problem self.problem = de.IVP(self.domain, variables=['u', 'ux', 'uxx']) self.problem.parameters['a'] = 2e-4 self.problem.parameters['b'] = 1e-4 self.problem.add_equation("dt(u) - a*dx(ux) - b*dx(uxx) = -u*ux") self.problem.add_equation("ux - dx(u) = 0") self.problem.add_equation("uxx - dx(ux) = 0")
def __init__(self, problem_params, dtype_u=dedalus_field, dtype_f=rhs_imex_dedalus_field): """ Initialization routine Args: problem_params (dict): custom parameters for the example dtype_u: mesh data type (will be passed parent class) dtype_f: mesh data type (will be passed parent class) """ if 'comm' not in problem_params: problem_params['comm'] = None # these parameters will be used later, so assert their existence essential_keys = ['nvars', 'nu', 'freq', 'comm'] for key in essential_keys: if key not in problem_params: msg = 'need %s to instantiate problem, only got %s' % ( key, str(problem_params.keys())) raise ParameterError(msg) # we assert that nvars looks very particular here.. this will be necessary for coarsening in space later on if problem_params['freq'] % 2 != 0: raise ProblemError('setup requires freq to be an equal number') xbasis = de.Fourier('x', problem_params['nvars'][0], interval=(0, 1), dealias=1) ybasis = de.Fourier('y', problem_params['nvars'][1], interval=(0, 1), dealias=1) domain = de.Domain([xbasis, ybasis], grid_dtype=np.float64, comm=problem_params['comm']) # invoke super init, passing number of dofs, dtype_u and dtype_f super(heat2d_dedalus_forced, self).__init__(init=domain, dtype_u=dtype_u, dtype_f=dtype_f, params=problem_params) self.x = self.init.grid(0, scales=1) self.y = self.init.grid(1, scales=1) self.rhs = self.dtype_u(self.init, val=0.0) self.problem = de.IVP(domain=self.init, variables=['u']) self.problem.parameters['nu'] = self.params.nu self.problem.add_equation( "dt(u) - nu * dx(dx(u)) - nu * dy(dy(u)) = 0") self.solver = self.problem.build_solver(de.timesteppers.SBDF1) self.u = self.solver.state['u']
def build_LHS(Nz): # Parameters terms = 1 dt = 1e-3 kx = 50 * np.pi sigma = 1 Prandtl = 1. Reynolds = 1e2 ts = de.timesteppers.SBDF3 # Create bases and domain z_basis = de.Chebyshev('z', Nz, interval=(-1, 1), dealias=3 / 2) domain = de.Domain([z_basis], grid_dtype=np.complex128) # 2D Boussinesq hydrodynamics problem = de.IVP(domain, variables=['p', 'b', 'u', 'w', 'bz', 'uz', 'wz'], ncc_cutoff=1e-10, max_ncc_terms=terms) problem.meta[:]['z']['dirichlet'] = True problem.parameters['P'] = 1 / Reynolds / Prandtl problem.parameters['R'] = 1 / Reynolds problem.parameters['kx'] = kx problem.parameters['sigma'] = sigma problem.substitutions['Bz'] = "exp(-(z-1)**2 / 2 / sigma**2)" problem.substitutions['dx(A)'] = "1j*kx*A" problem.add_equation("dx(u) + wz = 0") problem.add_equation("dt(b) - P*(dx(dx(b)) + dz(bz)) + Bz*w = 0") problem.add_equation("dt(u) - R*(dx(dx(u)) + dz(uz)) + dx(p) = 0") problem.add_equation("dt(w) - R*(dx(dx(w)) + dz(wz)) + dz(p) - b = 0") problem.add_equation("bz - dz(b) = 0") problem.add_equation("uz - dz(u) = 0") problem.add_equation("wz - dz(w) = 0") problem.add_bc("left(b) = 0") problem.add_bc("left(u) = 0") problem.add_bc("left(w) = 0") problem.add_bc("right(b) = 0") problem.add_bc("right(u) = 0") if kx == 0: problem.add_bc("right(p) = 0") else: problem.add_bc("right(w) = 0", ) # Build solver solver = problem.build_solver(ts) # Step solver to form pencil LHS for i in range(10): solver.step(dt) return solver.pencils[0].LHS
def build_problem(self, ncc_cutoff=1e-10): """Constructs and initial value problem of the current object's equation set Arguments: ---------- ncc_cutoff : float The largest coefficient magnitude to keep track of when building NCCs """ if self.variables is None: logger.error("IVP variables must be set before problem is built") self.problem = de.IVP(self.de_domain.domain, variables=self.variables, ncc_cutoff=ncc_cutoff)
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
def ivp(param, atmos=None, dtype=np.float64, comm=MPI.COMM_WORLD): if atmos is None: atmos = Atmosphere(param, dim=2, dtype=dtype, comm=comm) # Adiabatic viscous fully-compressible hydrodynamics problem = de.IVP(atmos.domain, variables=['a1', 'p1', 'u', 'w', 'uz', 'wz'], ncc_cutoff=param.ivp_cutoff, entry_cutoff=param.matrix_cutoff) problem.meta[:]['z']['dirichlet'] = True problem.parameters['a0'] = atmos.a0 problem.parameters['p0'] = atmos.p0 problem.parameters['a0z'] = atmos.a0z problem.parameters['p0z'] = atmos.p0z problem.parameters['U'] = param.U problem.parameters['μ'] = param.μ problem.parameters['γ'] = param.γ problem.parameters['k'] = param.k_tide problem.parameters['ω'] = param.ω_tide problem.parameters['σ'] = param.σ_tide problem.parameters['A'] = param.A_tide problem.parameters['Lz'] = param.Lz problem.substitutions['a0x'] = '0' problem.substitutions['p0x'] = '0' problem.substitutions['ux'] = "dx(u)" problem.substitutions['wx'] = "dx(w)" problem.substitutions['div_u'] = "ux + wz" problem.substitutions['txx'] = "μ*(2*ux - 2/3*div_u)" problem.substitutions['txz'] = "μ*(wx + uz)" problem.substitutions['tzz'] = "μ*(2*wz - 2/3*div_u)" problem.substitutions['φ'] = "A*exp(σ*t)*cos(k*x)*exp(k*(z - Lz))" problem.substitutions['cs20'] = "γ*p0*a0" problem.add_equation( "dt(u) + U*ux + a0*dx(p1) + a1*p0x - a0*(dx(txx) + dz(txz)) = - (u*ux + w*uz) - a1*dx(p1) + a1*(dx(txx) + dz(txz)) - dx(φ)" ) problem.add_equation( "dt(w) + U*wx + a0*dz(p1) + a1*p0z - a0*(dx(txz) + dz(tzz)) = - (u*wx + w*wz) - a1*dz(p1) + a1*(dx(txz) + dz(tzz)) - dz(φ)" ) problem.add_equation( "dt(a1) + U*dx(a1) + u*a0x + w*a0z - a0*div_u = - (u*dx(a1) + w*dz(a1)) + a1*div_u" ) problem.add_equation( "dt(p1) + U*dx(p1) + u*p0x + w*p0z + γ*p0*div_u = - (u*dx(p1) + w*dz(p1)) - γ*p1*div_u" ) problem.add_equation("uz - dz(u) = 0") problem.add_equation("wz - dz(w) = 0") problem.add_bc("left(txz) = 0") problem.add_bc("right(txz) = 0") problem.add_bc("left(w) = 0") problem.add_bc("right(w) = 0") return atmos, problem
def problem_setup(self, L=2., nx=192, nz=96, Prandtl_number=1., Rayleih_number=1e4, bc_type='no_slip'): self.L = float(L) self.nx = int(nx) self.nz = int(nz) x_basis = de.Fourier('x', int(nx), interval=(0, L), dealias=3 / 2) z_basis = de.Chebyshev('z', int(nz), interval=(0, 1), dealias=3 / 2) self.saving_shape = (int(nx * 3 / 2), int(nz * 3 / 2)) self.domain = de.Domain([x_basis, z_basis], grid_dtype=np.float64) self.problem = de.IVP( self.domain, variables=['T', 'Tz', 'psi', 'psiz', 'curl', 'curlz']) self.problem.parameters['L'] = L self.problem.parameters['nx'] = nx self.problem.parameters['nz'] = nz self.Pr = float(Prandtl_number) self.Ra = float(Rayleih_number) self.problem.parameters['Ra'] = self.Ra self.problem.parameters['Pr'] = self.Pr # Stream function relation to the speed self.problem.substitutions['u'] = "-dz(psi)" self.problem.substitutions['v'] = "dx(psi)" # Derivatives values relation to the main values self.problem.add_equation("psiz - dz(psi) = 0") self.problem.add_equation("curlz - dz(curl) = 0") self.problem.add_equation("Tz - dz(T) = 0") self.problem.add_equation("curl + dx(dx(psi)) + dz(psiz) = 0") self.problem.add_equation( "dt(curl)+Ra*Pr*dx(T)-Pr*(dx(dx(curl))+dz(curlz))=-(u*dx(curl)+v*curlz)" ) self.problem.add_equation("dt(T)-dx(dx(T))-dz(Tz)=-(u*dx(T)+v*Tz)") self.problem.add_bc("left(T) = 1") self.problem.add_bc("right(T) = 0") self.problem.add_bc("left(psi) = 0") self.problem.add_bc("right(psi) = 0") if bc_type not in ['no_slip', 'free_slip']: raise ValueError( "Boundary Conditions must be 'no_slip' or 'free_slip'") else: if bc_type == 'no_slip': self.problem.add_bc("left(psiz) = 0") self.problem.add_bc("right(psiz) = 0") if bc_type == 'free_slip': self.problem.add_bc("left(dz(psiz)) = 0") self.problem.add_bc("right(dz(psiz)) = 0")
def __init__(self, de_domain, atmosphere): """ Construct the equation class. Inputs are described in the class docstring. """ self.de_domain = de_domain self.atmosphere = atmosphere self.variables = [ 'u', 'u_z', 'v', 'v_z', 'w', 'w_z', 'T1', 'T1_z', 'ln_rho1' ] if not self.de_domain.threeD: self.variables.remove('v') self.variables.remove('v_z') self.problem = de.IVP(self.de_domain.domain, variables=self.variables) if not self.de_domain.threeD: self.problem.substitutions['v'] = '0' self.problem.substitutions['v_z'] = '0' self.problem.substitutions['dy(A)'] = '0*A'
def _get_solver(setup_problem, params, variables): ''' get solver for given variables ''' x_basis = de.Fourier('x', params['N_X'], interval=(0, params['XMAX']), dealias=3/2) z_basis = de.Chebyshev('z', params['N_Z'], interval=(0, params['ZMAX']), dealias=3/2) domain = de.Domain([x_basis, z_basis], np.float64) z = domain.grid(1) problem = de.IVP(domain, variables=variables) problem.parameters['L'] = params['XMAX'] problem.parameters['g'] = params['G'] problem.parameters['H'] = params['H'] problem.parameters['A'] = params['A'] problem.parameters['F'] = params['F'] problem.parameters['KX'] = params['KX'] problem.parameters['KZ'] = params['KZ'] problem.parameters['NU'] = params['NU'] problem.parameters['RHO0'] = params['RHO0'] problem.parameters['omega'] = params['OMEGA'] problem.parameters['ZMAX'] = params['ZMAX'] problem.parameters['Z0'] = 0.2 * params['ZMAX'] problem.parameters['S'] = params['H'] # rho0 stratification rho0 = domain.new_field() rho0.meta['x']['constant'] = True rho0['g'] = params['RHO0'] * np.exp(-z / params['H']) problem.parameters['rho0'] = rho0 setup_problem(problem, domain, params) # Build solver solver = problem.build_solver(de.timesteppers.RK222) solver.stop_sim_time = params['T_F'] solver.stop_wall_time = np.inf solver.stop_iteration = np.inf return solver, domain
def problem_setup(self): # 2D Boussinesq hydrodynamics self.problem = de.IVP( self.domain, variables=['p', 'b', 'u', 'v', 'w', 'bz', 'uz', 'vz', 'wz'], time='t') self.problem.meta['p', 'b', 'w', 'bz', 'wz']['x', 'y']['parity'] = 1 self.problem.meta['v', 'vz']['x']['parity'] = 1 self.problem.meta['v', 'vz']['y']['parity'] = -1 self.problem.meta['u', 'uz']['x']['parity'] = -1 self.problem.meta['u', 'uz']['y']['parity'] = 1 self.problem.parameters['P'] = 1 self.problem.parameters['R'] = self.Pr self.problem.parameters['F'] = self.F self.problem.add_equation("dx(u) + dy(v) + wz = 0") self.problem.add_equation( "dt(b) - P*(dx(dx(b)) + dy(dy(b)) + dz(bz)) = - u*dx(b) - v*dy(b) - w*bz" ) self.problem.add_equation( "dt(u) - R*(dx(dx(u)) + dy(dy(u)) + dz(uz)) + dx(p) = - u*dx(u) - v*dy(u) - w*uz" ) self.problem.add_equation( "dt(v) - R*(dx(dx(v)) + dy(dy(v)) + dz(vz)) + dy(p) = - u*dx(v) - v*dy(v) - w*vz" ) self.problem.add_equation( "dt(w) - R*(dx(dx(w)) + dy(dy(w)) + dz(wz)) + dz(p) - b = - u*dx(w) - v*dy(w) - w*wz" ) self.problem.add_equation("bz - dz(b) = 0") self.problem.add_equation("uz - dz(u) = 0") self.problem.add_equation("vz - dz(v) = 0") self.problem.add_equation("wz - dz(w) = 0") self.problem.add_bc("left(b) = -left(F*z)") self.problem.add_bc("left(u) = 0") self.problem.add_bc("left(v) = 0") self.problem.add_bc("left(w) = 0") self.problem.add_bc("right(b) = -right(F*z)") self.problem.add_bc("right(u) = 0") self.problem.add_bc("right(v) = 0") self.problem.add_bc("right(w) = 0", condition="(nx != 0) or (ny != 0)") self.problem.add_bc("integ_z(p) = 0", condition="(nx == 0) and (ny == 0)")
def problem_setup(self, mu): # Problem #swift-hohenberg: # self.problem = de.IVP(self.domain, variables=['u', 'ux', 'uxx']) # self.problem.parameters['r'] = mu # self.problem.parameters['qc'] = 0.5 # self.problem.parameters['v'] = 0.41 # self.problem.parameters['g'] = 1 # self.problem.add_equation("dt(u) -(r-qc*qc*qc*qc)*u + 2*qc*qc*uxx + dx(dx(uxx)) = v*u*u - g*u*u*u") # self.problem.add_equation("ux - dx(u) = 0") # self.problem.add_equation("uxx - dx(ux) = 0") #travelling wave: self.problem = de.IVP(self.domain, variables=['u', 'ux']) self.problem.parameters['k'] = 2 * np.pi / (5 * self.Lc) self.problem.parameters['w'] = 2 * np.pi / 200 self.problem.add_equation("dt(ux) - (w/k)*(w/k)*dx(dx(u)) = 0") self.problem.add_equation("dt(u) - ux = 0")
def get_solver(setup_problem, params): ''' get solver ''' x_basis = de.Fourier('x', params['N_X'], interval=(0, params['XMAX']), dealias=3 / 2) z_basis = de.Chebyshev('z', params['N_Z'], interval=(0, params['ZMAX']), dealias=3 / 2) domain = de.Domain([x_basis, z_basis], np.float64) z = domain.grid(1) problem = de.IVP(domain, variables=['P', 'rho', 'ux', 'uz']) problem.parameters['L'] = params['XMAX'] problem.parameters['g'] = params['G'] problem.parameters['H'] = params['H'] problem.parameters['A'] = params['A'] problem.parameters['F'] = params['F'] problem.parameters['KX'] = params['KX'] problem.parameters['KZ'] = params['KZ'] problem.parameters['NU'] = params['NU'] problem.parameters['RHO0'] = params['RHO0'] problem.parameters['omega'] = params['OMEGA'] problem.parameters['ZMAX'] = params['ZMAX'] # rho0 stratification # rho0 = domain.new_field() # rho0.meta['x']['constant'] = True # rho0['g'] = params['RHO0'] * np.exp(-z / params['H']) # problem.parameters['rho0'] = rho0 problem.parameters['rho0'] = params['RHO0'] setup_problem(problem, domain, params) # Build solver solver = problem.build_solver(params['TIMESTEPPER']) solver.stop_sim_time = params['T_F'] solver.stop_wall_time = np.inf solver.stop_iteration = np.inf return solver, domain
def build_LHS(Nz, bw, format, entry_cutoff=0): # Parameters dt = 1e-3 kx = 50 * np.pi sigma = 1 ts = de.timesteppers.RK222 # Create bases and domain z1 = de.Chebyshev('z', Nz, interval=(-1, 1), dealias=3 / 2) z2 = de.Chebyshev('z', Nz, interval=(1, 2), dealias=3 / 2) z3 = de.Chebyshev('z', Nz, interval=(2, 3), dealias=3 / 2) z_basis = de.Compound('z', [z1, z2, z3]) domain = de.Domain([z_basis], grid_dtype=np.complex128) # 2D Boussinesq hydrodynamics problem = de.IVP(domain, variables=['T', 'Tz'], ncc_cutoff=0, max_ncc_terms=bw, entry_cutoff=entry_cutoff) problem.meta[:]['z']['dirichlet'] = True problem.parameters['kx'] = kx problem.parameters['sigma'] = sigma problem.substitutions['kappa'] = "exp(-(z-1)**2 / 2 / sigma**2)" problem.substitutions['dx(A)'] = "1j*kx*A" problem.add_equation("dt(T) - dx(kappa*dx(T)) - dz(kappa*Tz) = 0") problem.add_equation("Tz - dz(T) = 0") problem.add_bc("left(T) = 0") problem.add_bc("right(T) = 0") # Build solver solver = problem.build_solver(ts) # Step solver to form pencil LHS for i in range(1): solver.step(dt) return solver, solver.pencils[0].LHS.asformat(format)
def get_solver(params): ''' sets up solver ''' x_basis = de.Fourier('x', N_X, interval=(0, XMAX), dealias=3 / 2) z_basis = de.Fourier('z', N_Z, interval=(0, ZMAX), dealias=3 / 2) domain = de.Domain([x_basis, z_basis], np.float64) problem = de.IVP(domain, variables=['P', 'rho', 'ux', 'uz']) problem.parameters.update(params) problem.substitutions['sponge'] = 'SPONGE_STRENGTH * 0.5 * ' +\ '(2 + tanh((z - SPONGE_HIGH) / (SPONGE_WIDTH * (ZMAX - SPONGE_HIGH))) - ' +\ 'tanh((z - SPONGE_LOW) / (SPONGE_WIDTH * (SPONGE_LOW))))' problem.substitutions['mask'] = \ '0.5 * (1 + tanh((z - (Z0 + 3 * S)) / (S / 2)))' problem.add_equation('dx(ux) + dz(uz) = 0', condition='nx != 0 or nz != 0') problem.add_equation( 'dt(rho) - RHO0 * uz / H' + '- NU * (N_Z/N_X)**6 * dx(dx(dx(dx(dx(dx(rho))))))' + '- NU * dz(dz(dz(dz(dz(dz(rho))))))' + '= -sponge * rho' + '- mask * (ux * dx(rho) + uz * dz(rho))' + '+ F * exp(-(z - Z0)**2 / (2 * S**2)) *cos(KX * x - OMEGA * t)') problem.add_equation('dt(ux) + dx(P) / RHO0' + '- NU * (N_Z/N_X)**6 * dx(dx(dx(dx(dx(dx(ux))))))' + '- NU * dz(dz(dz(dz(dz(dz(ux))))))' + '= - sponge * ux' + '- mask * (ux * dx(ux) + uz * dz(ux))') problem.add_equation('dt(uz) + dz(P) / RHO0 + rho * g / RHO0' + '- NU * (N_Z/N_X)**6 * dx(dx(dx(dx(dx(dx(uz))))))' + '- NU * dz(dz(dz(dz(dz(dz(uz))))))' + '= -sponge * uz' + '- mask * (ux * dx(uz) + uz * dz(uz))') problem.add_equation('P = 0', condition='nx == 0 and nz == 0') # Build solver solver = problem.build_solver(de.timesteppers.RK443) solver.stop_sim_time = T_F solver.stop_wall_time = np.inf solver.stop_iteration = np.inf return solver, domain
Ha = 1. Re = 1. Rm = 1. Pi = 1. tau = 0.1 stop_time = 10 data_dir = "scratch" x = de.Fourier('x', nx, interval=[0, Lx], dealias=3 / 2) y = de.Chebyshev('y', ny, interval=[-Ly / 2, Ly / 2], dealias=3 / 2) domain = de.Domain([x, y], grid_dtype='float') hartmann = de.IVP(domain, variables=['vx', 'vy', 'Az', 'p', 'vx_y', 'vy_y', 'Az_y']) hartmann.parameters['Ha'] = Ha hartmann.parameters['Re'] = Re hartmann.parameters['Rm'] = Rm hartmann.parameters['Pi'] = Pi # pressure gradient driving flow hartmann.parameters['Lx'] = Lx hartmann.parameters['Ly'] = Ly hartmann.parameters['tau'] = tau hartmann.substitutions['Bx'] = "Az_y" hartmann.substitutions['By'] = "-dx(Az) + 1." hartmann.substitutions['Lap(A, Ay)'] = "dx(dx(A)) + dy(Ay)" hartmann.substitutions['Jz'] = "-Lap(Az, Az_y)" hartmann.substitutions['Avg_x(A)'] = "integ(A,'x')/Lx" # Navier Stokes hartmann.add_equation(
def __init__(self, nx = 32, ny = 32, nz = 32, Lx = 2*pi, # [m] Ly = 2*pi, # [m] Lz = 2*pi, # [m] ν = 1.05e-6, # Kinematic viscosity [m²/s] # "Background" (non-evolving) fields: u_bg = "0", v_bg = "0", w_bg = "0", p_bg = "0", include_linear_bg = False, # Include linear background terms in model formulation closure = None, # Subgrid closure **params # Additional parameters to be added to dedalus problem ): Flow.__init__(self, nx, ny, nz, Lx, Ly, Lz) self.xlimits = (-Lx/2, Lx/2) self.ylimits = (-Ly/2, Ly/2) self.zlimits = (-Lz/2, Lz/2) # Create bases and domain self.xbasis = xbasis = de.Fourier('x', nx, interval=self.xlimits, dealias=3/2) self.ybasis = ybasis = de.Fourier('y', ny, interval=self.ylimits, dealias=3/2) self.zbasis = zbasis = de.Fourier('z', nz, interval=self.zlimits, dealias=3/2) self.domain = domain = de.Domain([xbasis, ybasis, zbasis], grid_dtype=np.float64) self.x = domain.grid(0) self.y = domain.grid(1) self.z = domain.grid(2) bind_parameters(self, ν=ν, **params) # Problem set-up variables = ['p', 'u', 'v', 'w'] add_closure_variables(variables, closure) self.problem = problem = de.IVP(domain, variables=variables, time='t') add_parameters(problem, ν=ν, **params) bind_parameters(self, ν=ν, **params) problem.substitutions['u_bg'] = u_bg problem.substitutions['v_bg'] = v_bg problem.substitutions['w_bg'] = w_bg problem.substitutions['p_bg'] = p_bg problem.substitutions['U'] = "u + u_bg" problem.substitutions['V'] = "v + v_bg" problem.substitutions['W'] = "w + w_bg" add_first_derivative_substitutions(problem, ['u', 'v', 'w', 'p', 'U', 'V', 'W', 'u_bg', 'v_bg', 'w_bg', 'p_bg'], ['x', 'y', 'z'] ) add_closure_substitutions(problem, closure, u='U', v='V', w='W') add_closure_equations(problem, closure, u='U', v='V', w='W') problem.substitutions['div(f1, f2, f3)'] = "dx(f1) + dy(f2) + dz(f3)" ## Momentum equations: # Primary linear terms linear_x = "px - ν*div(ux, uy, uz)" linear_y = "py - ν*div(vx, vy, vz)" linear_z = "pz - ν*div(wx, wy, wz)" # Linear background terms if include_linear_bg: linear_bg_x = "p_bgx - ν*div(u_bgx, u_bgy, u_bgz)" linear_bg_y = "p_bgy - ν*div(v_bgx, v_bgy, v_bgz)" linear_bg_z = "p_bgz - ν*div(w_bgx, w_bgy, w_bgz)" else: linear_bg_x = "0" linear_bg_y = "0" linear_bg_z = "0" xmom = f"dt(u) + {linear_x} + Lu_sgs = - {linear_bg_x} - U*Ux - V*Uy - W*Uz + Nu_sgs" ymom = f"dt(v) + {linear_y} + Lv_sgs = - {linear_bg_y} - U*Vx - V*Vy - W*Vz + Nv_sgs" zmom = f"dt(w) + {linear_z} + Lw_sgs = - {linear_bg_z} - U*Wx - V*Wy - W*Wz + Nw_sgs" problem.add_equation(xmom) problem.add_equation(ymom) problem.add_equation(zmom) # Continuity equation problem.add_equation("ux + vy + wz = - u_bgx - v_bgy - w_bgz", condition="(nx != 0) or (ny != 0) or (nz != 0)") problem.add_equation("p = 0", condition="(nx == 0) and (ny == 0) and (nz == 0)")
logger = logging.getLogger(__name__) # Parameters Lx, Lz = (4., 1.) Prandtl = 1. Rayleigh = 4e9 # Create bases and domain Nx, Nz = 2048, 512 x_basis = de.Fourier('x', Nx, interval=(0, Lx), dealias=3/2) z_basis = de.Chebyshev('z', Nz, interval=(-Lz/2, Lz/2), dealias=3/2) domain = de.Domain([x_basis, z_basis], grid_dtype=np.float64) # 2D Boussinesq hydrodynamics problem = de.IVP(domain, variables=['p','b','u','w','bz','uz','wz']) problem.meta['p','b','u','w']['z']['dirichlet'] = True problem.parameters['P'] = (Rayleigh * Prandtl)**(-1/2) problem.parameters['R'] = (Rayleigh / Prandtl)**(-1/2) problem.parameters['F'] = F = 1 problem.parameters['Lx'] = Lx problem.add_equation("dx(u) + wz = 0") problem.add_equation("dt(b) - P*(dx(dx(b)) + dz(bz)) - F*w = -(u*dx(b) + w*bz)") problem.add_equation("dt(u) - R*(dx(dx(u)) + dz(uz)) + dx(p) = -(u*dx(u) + w*uz)") problem.add_equation("dt(w) - R*(dx(dx(w)) + dz(wz)) + dz(p) - b = -(u*dx(w) + w*wz)") problem.add_equation("bz - dz(b) = 0") problem.add_equation("uz - dz(u) = 0") problem.add_equation("wz - dz(w) = 0") problem.add_bc("left(b) = 0") problem.add_bc("left(u) = 0") problem.add_bc("left(w) = 0")
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 problem.add_equation("dx(u) + dy(v) + wz = 0") problem.add_equation("dt(b) - P*(dx(dx(b)) + dy(dy(b)) + dz(bz)) = - u*dx(b) - v*dy(b) - w*bz") problem.add_equation("dt(u) - R*(dx(dx(u)) + dy(dy(u)) + dz(uz)) + dx(p) = - u*dx(u) - v*dy(u) - w*uz") problem.add_equation("dt(v) - R*(dx(dx(v)) + dy(dy(v)) + dz(vz)) + dy(p) = - u*dx(v) - v*dy(v) - w*vz") problem.add_equation("dt(w) - R*(dx(dx(w)) + dy(dy(w)) + dz(wz)) + dz(p) - b = - u*dx(w) - v*dy(w) - w*wz") problem.add_equation("bz - dz(b) = 0")
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 problem.meta['ct']['y1']['parity'] = -1 problem.meta['css']['y0']['parity'] = -1 problem.meta['cts']['y0']['parity'] = -1 problem.meta['cst']['y0']['parity'] = -1 problem.meta['ctt']['y0']['parity'] = -1 problem.meta['css']['y1']['parity'] = -1 problem.meta['cts']['y1']['parity'] = -1 problem.meta['cst']['y1']['parity'] = -1
nx = 512 * 2 coef_dealias = 2 / 3 n = int(coef_dealias * nx) dealias = nx / n nx, ny = (n, n) # Create bases and domain x_basis = de.Fourier('x', nx, interval=(0, lx), dealias=dealias) y_basis = de.Fourier('y', ny, interval=(0, ly), dealias=dealias) domain = de.Domain([x_basis, y_basis], grid_dtype=np.float64) # Stream function-vorticity formulation variables = ['psi'] problem = de.IVP(domain, variables=variables) Reynolds = 1e4 problem.parameters['Re'] = Reynolds problem.substitutions['u'] = "dy(psi)" problem.substitutions['v'] = "-dx(psi)" problem.substitutions['rot'] = "- dx(dx(psi)) - dy(dy(psi))" problem.substitutions['rotx'] = "dx(rot)" problem.substitutions['roty'] = "dy(rot)" problem.add_equation( 'dt(rot) - (1/Re)*(dx(rotx) + dy(roty)) = - u*rotx - v*roty', condition="(nx != 0) or (ny != 0)") problem.add_equation("psi = 0", condition="(nx == 0) and (ny == 0)") # with first-order reduction equations... # problem.add_equation('rot + dy(u) - dx(v) = 0')
Pr = rpf.Pr Ra = rpf.Ra Np = rpf.Np Ta = rpf.Ta Lat = rpf.latitude m = rpf.m theta = rpf.theta # Create bases and domain y_basis = de.Fourier('y', Ny, interval=(0, Ly), 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([y_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', 'v', 'w', 'sz', 'uz', 'vz', 'wz', 'L_buoy', 'L_diss']) problem.meta['p','s','u','w']['z']['dirichlet'] = True # Defining model parameters problem.parameters['Ly'] = Ly problem.parameters['Lz'] = Lz problem.parameters['Ra'] = Ra problem.parameters['Pr'] = Pr problem.parameters['Ta'] = Ta problem.parameters['Lat'] = Lat problem.parameters['m'] = m problem.parameters['theta'] = theta problem.parameters['X'] = Ra/Pr problem.parameters['Y'] = (Pr*Pr*theta) / Ra problem.parameters['T'] = Ta**(1/2)