# Note: SBDF2 timestepper does not currently work with AE if args['--SBDF2']: ts = de.timesteppers.SBDF2 if args['--SBDF4']: ts = de.timesteppers.SBDF4 else: ts = de.timesteppers.RK443 cfl_safety = float(args['--safety']) mag_cfl_safety = float(args['--mag_safety']) solver = problem.build_solver(ts) logger.info('Solver built') ### 6. Set initial conditions: noise or loaded checkpoint checkpoint = Checkpoint(data_dir) checkpoint_min = 30 restart = args['--restart'] if restart is None: p = solver.state['p'] T1 = solver.state['T1'] T1_z = solver.state['T1_z'] p.set_scales(domain.dealias) T1.set_scales(domain.dealias) T1_z.set_scales(domain.dealias) z_de = domain.grid(-1, scales=domain.dealias) A0 = 1e-6 #Add noise kick noise = global_noise(domain, int(args['--seed']))
problem.add_bc("right(p) = 0", condition="(nx == 0) and (ny == 0)") problem.add_bc("right(w) = 0", condition="(nx != 0) or (ny != 0)") ### 5. Build solver # Note: SBDF2 timestepper does not currently work with AE. #ts = de.timesteppers.SBDF2 if args['--RK443']: ts = de.timesteppers.RK443 else: ts = de.timesteppers.RK222 cfl_safety = float(args['--safety']) solver = problem.build_solver(ts) logger.info('Solver built') ### 6. Set initial conditions: noise or loaded checkpoint checkpoint = Checkpoint(data_dir) checkpoint_min = 30 restart = args['--restart'] TT_to_FT = args['--TT_to_FT'] not_corrected_times = True true_t_ff = 1 if restart is None and TT_to_FT is None: p = solver.state['p'] T1 = solver.state['T1'] T1_z = solver.state['T1_z'] p.set_scales(domain.dealias) T1.set_scales(domain.dealias) T1_z.set_scales(domain.dealias) z_de = domain.grid(-1, scales=domain.dealias) A0 = 1e-6
######################################################## # Timestepping logger.info("buoyancy_time = {}".format(buoyancy_time)) output_cadence = float(args['--out_cadence']) * buoyancy_time max_dt = safety * 0.1 * buoyancy_time / 4 #np.sqrt(Reynolds) dt = max_dt / 10 ######################################################### # Initial conditions & Checkpointing T1 = solver.state['T1'] T1_z = solver.state['T1_z'] ln_rho1 = solver.state['ln_rho1'] logger.info('checkpointing in {}'.format(data_dir)) checkpoint = Checkpoint(data_dir) mode = 'overwrite' if restart is None: therm = Thermal(domain, atmosphere, falling=True, radius=radius, r_width=delta_r, A0=epsilon, z_pert=z_pert) therm.set_thermal(T1, T1_z, ln_rho1) else: logger.info("restarting from {}".format(restart)) dt = checkpoint.restart(restart, solver) mode = 'append' checkpoint.set_checkpoint(solver, sim_dt=buoyancy_time, mode=mode)
logger.info('Adding BC "{:15s}" of form: "{:s}" (condition: {})'.format(k, bc[0], bc[1])) problem.add_bc(bc[0], condition=bc[1]) ### 5. Build solver # Note: SBDF2 timestepper does not currently work with AE. #ts = de.timesteppers.SBDF2 if args['--RK443']: ts = de.timesteppers.RK443 else: ts = de.timesteppers.RK222 cfl_safety = float(args['--safety']) solver = problem.build_solver(ts) logger.info('Solver built') ### 6. Set initial conditions: noise or loaded checkpoint checkpoint = Checkpoint(data_dir) checkpoint_dt = 100 restart = args['--restart'] not_corrected_times = True if restart is None: x_de = domain.grid(0, scales=domain.dealias) y_de = domain.grid(1, scales=domain.dealias) z_de = domain.grid(-1, scales=domain.dealias) f1 = 1.0*np.sin(34*np.pi*x_de/aspect) + 1.1*np.cos(32*np.pi*x_de/aspect) + 0.9*np.sin(38*np.pi*x_de/aspect) f2 = 1.0*np.cos(24*np.pi*x_de/aspect) - 0.7*np.sin(28*np.pi*x_de/aspect) + 1.4*np.cos(34*np.pi*x_de/aspect) g1 = 0.6*np.cos(38*np.pi*y_de/aspect) - 1.0*np.sin(46*np.pi*y_de/aspect) - 1.2*np.sin(28*np.pi*y_de/aspect) g2 = 1.0*np.cos(32*np.pi*y_de/aspect) + 0.8*np.sin(36*np.pi*y_de/aspect) - 1.1*np.cos(42*np.pi*y_de/aspect) h1 = 1.0*np.sin(13*np.pi*z_de) - 0.8*np.sin(16*np.pi*z_de) + 1.2*np.sin(20*np.pi*z_de) h2 = 1.0*np.sin(15*np.pi*z_de) - 1.5*np.sin(12*np.pi*z_de) + 0.7*np.sin(18*np.pi*z_de)
def solve_IVP(self, dt, CFL, data_dir, analysis_tasks, task_args=(), pre_loop_args=(), task_kwargs={}, pre_loop_kwargs={}, time_div=None, track_fields=['Pe'], threeD=False, Hermitian_cadence=100, no_join=False, mode='append'): """Logic for a while-loop that solves an initial value problem. Parameters ---------- dt : float The initial timestep of the simulation CFL : a Dedalus CFL object A CFL object that calculates the timestep of the simulation on the fly data_dir : string The parent directory of output files analysis_tasks : OrderedDict() An OrderedDict of dedalus FileHandler objects task_args, task_kwargs : list, dict, optional arguments & keyword arguments to the self._special_tasks() function pre_loop_args, pre_loop_kwargs: list, dict, optional arguments & keyword arguments to the self.pre_loop_setup() function time_div : float, optional A siulation time to divide the normal time by for easier output tracking threeD : bool, optional If True, occasionally force the solution to grid space to remove Hermitian errors Hermitian_cadence : int, optional The number of timesteps between grid space forcings in 3D. no_join : bool, optional If True, do not join files at the end of the simulation run. mode : string, optional Dedalus output mode for final checkpoint. "append" or "overwrite" args, kwargs : list and dictionary Additional arguments and keyword arguments to be passed to the self.special_tasks() function """ # Flow properties self.flow = flow_tools.GlobalFlowProperty(self.solver, cadence=1) for f in track_fields: self.flow.add_property(f, name=f) self.pre_loop_setup(*pre_loop_args, **pre_loop_kwargs) start_time = time.time() # Main loop count = 0 try: logger.info('Starting loop') init_time = self.solver.sim_time start_iter = self.solver.iteration while (self.solver.ok): dt = CFL.compute_dt() self.solver.step(dt) #, trim=True) # prevents blow-up over long timescales in 3D due to hermitian-ness effective_iter = self.solver.iteration - start_iter if threeD and effective_iter % Hermitian_cadence == 0: for field in self.solver.state.fields: field.require_grid_space() self.special_tasks(*task_args, **task_kwargs) #reporting string self.iteration_report(dt, track_fields, time_div=time_div) if not np.isfinite(self.flow.grid_average(track_fields[0])): break except: raise logger.error('Exception raised, triggering end of main loop.') finally: end_time = time.time() main_loop_time = end_time - start_time n_iter_loop = self.solver.iteration - 1 logger.info('Iterations: {:d}'.format(n_iter_loop)) logger.info('Sim end time: {:f}'.format(self.solver.sim_time)) logger.info('Run time: {:f} sec'.format(main_loop_time)) logger.info('Run time: {:f} cpu-hr'.format( main_loop_time / 60 / 60 * self.de_domain.domain.dist.comm_cart.size)) logger.info('iter/sec: {:f} (main loop only)'.format( n_iter_loop / main_loop_time)) try: final_checkpoint = Checkpoint( data_dir, checkpoint_name='final_checkpoint') final_checkpoint.set_checkpoint(self.solver, wall_dt=1, mode=mode) self.solver.step( dt) #clean this up in the future...works for now. post.merge_process_files(data_dir + '/final_checkpoint/', cleanup=False) except: raise print('cannot save final checkpoint') finally: if not no_join: logger.info('beginning join operation') post.merge_analysis(data_dir + 'checkpoint') for key, task in analysis_tasks.items(): logger.info(task.base_path) post.merge_analysis(task.base_path) logger.info(40 * "=") logger.info('Iterations: {:d}'.format(n_iter_loop)) logger.info('Sim end time: {:f}'.format(self.solver.sim_time)) logger.info('Run time: {:f} sec'.format(main_loop_time)) logger.info('Run time: {:f} cpu-hr'.format( main_loop_time / 60 / 60 * self.de_domain.domain.dist.comm_cart.size)) logger.info('iter/sec: {:f} (main loop only)'.format( n_iter_loop / main_loop_time))
def FC_TriLayer_convection(input_dict): """ A driver function for running FC convection in Dedalus. Parameters ---------- input_dict : dict A dictionary of strings whose keys are all of the options specified above in the FC_poly.py docstring """ import os from collections import OrderedDict from dedalus.tools.config import config from logic.functions import mpi_makedirs #Get info on data directory, create directories, setup logging # (Note: this order of imports is bad form, but gets logs properly outputting) data_dir, case_name = name_case(input_dict) mpi_makedirs(data_dir) logdir = os.path.join(data_dir, 'logs') mpi_makedirs(logdir) file_level = config['logging']['file_level'] = 'debug' filename = config['logging']['filename'] = os.path.join( logdir, 'dedalus_log') from dedalus import public as de from dedalus.extras import flow_tools from logic.atmospheres import TriLayerIH from logic.domains import DedalusDomain from logic.experiments import CompressibleConvection from logic.problems import DedalusIVP from logic.equations import KappaMuFCE from logic.ae_tools import FCAcceleratedEvolutionIVP from logic.outputs import initialize_output, ae_initialize_output from logic.checkpointing import Checkpoint from logic.field_averager import AveragerFCAE, AveragerFCStructure import logging logger = logging.getLogger(__name__) logger.info("Running polytrope case: {}".format(case_name)) logger.info("Saving run in: {}".format(data_dir)) # Read in command line args & process them # Atmosphere params Ra, Pr, n_rho_rzT, n_rho_cz, n_rho_rzB, eps, aspect = [ float(input_dict[k]) for k in ('--Rayleigh', '--Prandtl', '--n_rho_rzT', '--n_rho_cz', '--n_rho_rzB', '--epsilon', '--aspect') ] threeD = input_dict['--3D'] # BCs thermal_BC = OrderedDict((('flux', False), ('temp', False), ('flux_temp', False), ('temp_flux', False))) velocity_BC = OrderedDict((('stress_free', False), ('no_slip', False))) thermal_BC[input_dict['--thermal_BC']] = True velocity_BC[input_dict['--velocity_BC']] = True # Coeff resolutions nx, ny, nz = [int(input_dict[n]) for n in ['--nx', '--ny', '--nz']] # 3D processor mesh. mesh = input_dict['--mesh'] if mesh is not None: mesh = mesh.split(',') mesh = [int(mesh[0]), int(mesh[1])] # Stop conditions run_time_wall, run_time_buoy, run_time_therm = [ input_dict[t] for t in ['--run_time_wall', '--run_time_buoy', '--run_time_therm'] ] run_time_wall = float(run_time_wall) if run_time_buoy is not None: run_time_buoy = float(run_time_buoy) run_time_therm = None logger.info( "Terminating run after {} buoyancy times".format(run_time_buoy)) else: run_time_therm = float(run_time_therm) logger.info( "Terminating run after {} thermal times".format(run_time_therm)) # Initialize atmosphere class atmo_kwargs = OrderedDict([('epsilon', eps), ('n_rho_rzT', n_rho_rzT), ('n_rho_cz', n_rho_cz), ('n_rho_rzB', n_rho_rzB), ('gamma', 5. / 3), ('R', 1)]) atmosphere = TriLayerIH(**atmo_kwargs) # Initialize domain class resolution = (nz, nx, ny) if not threeD: resolution = resolution[:2] domain_args = (atmosphere, resolution, aspect) domain_kwargs = OrderedDict((('mesh', mesh), )) de_domain = DedalusDomain(*domain_args, **domain_kwargs) #Set diffusivities experiment_args = (de_domain, atmosphere, Ra, Pr) experiment_kwargs = {} experiment = CompressibleConvection(*experiment_args, **experiment_kwargs) #Set up problem and equations if args['--ae']: problem_type = FCAcceleratedEvolutionIVP else: problem_type = DedalusIVP de_problem = problem_type(de_domain) equations = KappaMuFCE(thermal_BC, velocity_BC, atmosphere, de_domain, de_problem) atmosphere.save_atmo_file('./', de_domain) # Build solver, set stop times de_problem.build_solver(de.timesteppers.RK222) #Setup checkpointing and initial conditions checkpoint = Checkpoint(data_dir) dt, mode = experiment.set_IC( de_problem.solver, eps, checkpoint, restart=args['--restart'], seed=int(args['--seed']), checkpoint_dt=float(args['--checkpoint_buoy']) * atmosphere.atmo_params['t_buoy']) if run_time_buoy is None: stop_sim_time = run_time_therm * atmosphere.atmo_params['t_therm'] else: stop_sim_time = run_time_buoy * atmosphere.atmo_params['t_buoy'] if args['--run_time_restarted']: stop_sim_time += de_problem.solver.sim_time de_problem.set_stop_condition(stop_wall_time=run_time_wall * 3600, stop_sim_time=stop_sim_time) #Set up outputs output_dt = float(args['--output_dt']) * atmosphere.atmo_params['t_buoy'] if args['--ae_outs']: analysis_tasks = ae_initialize_output( de_domain, de_problem, data_dir, output_dt=output_dt, output_vol_dt=atmosphere.atmo_params['t_buoy'], mode=mode) # volumes_output=True) else: analysis_tasks = initialize_output( de_domain, de_problem, data_dir, output_dt=output_dt, output_vol_dt=atmosphere.atmo_params['t_buoy'], mode=mode) # volumes_output=True) # Ensure good initial dt and setup CFL max_dt = min( (0.2, float(args['--output_dt']))) * atmosphere.atmo_params['t_buoy'] if dt is None: dt = max_dt cfl_safety = 0.1 CFL = flow_tools.CFL(de_problem.solver, initial_dt=dt, cadence=1, safety=cfl_safety * 2, max_change=1.5, min_change=0.5, max_dt=max_dt, threshold=0.1) if threeD: CFL.add_velocities(('u', 'v', 'w')) else: CFL.add_velocities(('u', 'w')) # Solve the IVP. if args['--ae']: task_args = (thermal_BC, ) pre_loop_args = ((AveragerFCAE, AveragerFCStructure), (True, False), data_dir, atmo_kwargs, CompressibleConvection, experiment_args, experiment_kwargs) task_kwargs = {} pre_loop_kwargs = { 'sim_time_start': int(args['--ae_start_time']) * atmosphere.atmo_params['t_buoy'], 'min_bvp_time': 10 * atmosphere.atmo_params['t_buoy'], 'between_ae_wait_time': 20 * atmosphere.atmo_params['t_buoy'], 'later_bvp_time': 20 * atmosphere.atmo_params['t_buoy'], 'ae_convergence': 1e-2, 'bvp_threshold': 1e-2, 'min_bvp_threshold': 5e-3 } solve_args = (dt, CFL, data_dir, analysis_tasks) solve_kwargs = { 'task_args': task_args, 'pre_loop_args': pre_loop_args, 'task_kwargs': task_kwargs, 'pre_loop_kwargs': pre_loop_kwargs, 'time_div': atmosphere.atmo_params['t_buoy'], 'track_fields': ['Pe_rms', 'dissipation'], 'threeD': threeD, 'Hermitian_cadence': 100, 'no_join': args['--no_join'], 'mode': mode } de_problem.solve_IVP(*solve_args, **solve_kwargs) else: de_problem.solve_IVP(dt, CFL, data_dir, analysis_tasks, time_div=atmosphere.atmo_params['t_buoy'], track_fields=['Pe_rms', 'dissipation'], threeD=threeD, Hermitian_cadence=100, no_join=args['--no_join'], mode=mode)
problem.add_bc("left(wr) = 0") problem.add_bc("left(rho1r) = 0") ######################### # Initialization of run ######################### solver = problem.build_solver(de.timesteppers.RK443) logger.info('Solver built') # Set up initial conditions rho1 = solver.state['rho1'] rho1r = solver.state['rho1r'] w = solver.state['w'] logger.info('checkpointing in {}'.format(data_dir)) checkpoint = Checkpoint(data_dir) mode = 'overwrite' restart = args['--restart'] # Simulation termination parameters solver.stop_sim_time = 20. solver.stop_wall_time = np.inf solver.stop_iteration = np.inf ################################# # Initial conditions from Daniel ################################# noise = domain.new_field() noise.meta['r']['dirichlet'] = True noise.set_scales(domain.dealias)