def run(**kwargs): # L-going fast wave arguments = [ 'time/ncycle_out=0', 'problem/wave_flag=0', 'problem/vflow=0.0', 'mesh/refinement=static', 'mesh/nx1=32', 'mesh/nx2=16', 'mesh/nx3=16', 'meshblock/nx1=8', 'meshblock/nx2=8', 'meshblock/nx3=8', 'output2/dt=-1', 'time/tlim=2.0', 'problem/compute_error=true' ] athena.run('mhd/athinput.linear_wave3d', arguments, lcov_test_suffix='serial') os.system('rm -rf obj') os.system('mv obj_hybrid obj') os.system('mv bin/athena_hybrid bin/athena') athena.mpirun(kwargs['mpirun_cmd'], kwargs['mpirun_opts'], 1, 'mhd/athinput.linear_wave3d', arguments + ['mesh/num_threads=1']) # 4 total threads = 2 MPI ranks x 2 OpenMP threads / rank athena.mpirun(kwargs['mpirun_cmd'], kwargs['mpirun_opts'], 2, 'mhd/athinput.linear_wave3d', arguments + ['mesh/num_threads=2'], lcov_test_suffix='hybrid') return 'skip_lcov'
def run(**kwargs): arguments = [ 'time/ncycle_out=10', 'mesh/nx1=64', 'mesh/nx2=32', 'mesh/nx3=32', 'meshblock/nx1=16', 'meshblock/nx2=16', 'meshblock/nx3=16', 'output2/dt=-1', 'time/tlim=1.0', 'problem/compute_error=true' ] # athena.run('hydro/athinput.jeans_3d', arguments) os.system('mv bin/athena_fft bin/athena') athena.run('hydro/athinput.jeans_3d', arguments) # os.system('mv bin/athena_mpi_mg bin/athena') # athena.mpirun(kwargs['mpirun_cmd'], kwargs['mpirun_opts'], # 1, 'hydro/athinput.jeans_3d', arguments) # athena.mpirun(kwargs['mpirun_cmd'], kwargs['mpirun_opts'], # 2, 'hydro/athinput.jeans_3d', arguments) # athena.mpirun(kwargs['mpirun_cmd'], kwargs['mpirun_opts'], # 4, 'hydro/athinput.jeans_3d', arguments) os.system('mv bin/athena_mpi_fft bin/athena') athena.mpirun(kwargs['mpirun_cmd'], kwargs['mpirun_opts'], 1, 'hydro/athinput.jeans_3d', arguments) athena.mpirun(kwargs['mpirun_cmd'], kwargs['mpirun_opts'], 2, 'hydro/athinput.jeans_3d', arguments) athena.mpirun(kwargs['mpirun_cmd'], kwargs['mpirun_opts'], 4, 'hydro/athinput.jeans_3d', arguments)
def run(**kwargs): # L-going fast wave arguments = [ 'time/ncycle_out=0', 'problem/wave_flag=0', 'problem/vflow=0.0', 'mesh/refinement=static', 'mesh/nx1=32', 'mesh/nx2=16', 'mesh/nx3=16', 'meshblock/nx1=8', 'meshblock/nx2=8', 'meshblock/nx3=8', 'output2/dt=-1', 'time/tlim=2.0', 'problem/compute_error=true' ] athena.run('mhd/athinput.linear_wave3d', arguments, lcov_test_suffix='serial') os.system('rm -rf obj') os.system('mv obj_mpi obj') os.system('mv bin/athena_mpi bin/athena') athena.mpirun(kwargs['mpirun_cmd'], kwargs['mpirun_opts'], 1, 'mhd/athinput.linear_wave3d', arguments) athena.mpirun(kwargs['mpirun_cmd'], kwargs['mpirun_opts'], 2, 'mhd/athinput.linear_wave3d', arguments) athena.mpirun(kwargs['mpirun_cmd'], kwargs['mpirun_opts'], 4, 'mhd/athinput.linear_wave3d', arguments, lcov_test_suffix='mpi') return 'skip_lcov'
def run(**kwargs): arguments = { 'time/ncycle_out': '0', 'mesh/nx1': '1', 'mesh/nx2': '1', 'mesh/nx3': '1', 'mesh/ix1_bc': 'periodic', 'mesh/ox1_bc': 'periodic', 'mesh/ix2_bc': 'periodic', 'mesh/ox2_bc': 'periodic', 'mesh/ix3_bc': 'periodic', 'mesh/ox3_bc': 'periodic', 'time/cfl_number': '0.3', 'problem/shock_dir': '1', 'problem/compute_error': 'true'} for flux in _fluxes: move(_exec + '_' + flux, _exec) os.system('mv obj_' + flux + ' obj') for xdir in _xdirs: for nx in _nxs: args = dict(arguments) args['mesh/nx' + repr(xdir)] = repr(nx) for i in range(1, xdir): args['mesh/nx' + repr(i)] = '4' args['mesh/ix' + repr(xdir) + '_bc'] = 'outflow' args['mesh/ox' + repr(xdir) + '_bc'] = 'outflow' args['problem/shock_dir'] = repr(xdir) athena.run('hydro/athinput.sod', [i + '=' + args[i] for i in args], lcov_test_suffix=flux) os.system('rm -rf obj') return 'skip_lcov'
def run(): # Parameters rho = 1.0 pgas = 0.5 vx = 0.1 vy = 0.15 vz = 0.05 bx = 1.0 by = 2.0 / 3.0 bz = 1.0 / 3.0 gamma_adi = 4.0 / 3.0 # Go through all waves at low and high resolutions for wave_flag in range(7): wavespeed = calculate_wavespeed(rho, pgas, vx, vy, vz, bx, by, bz, gamma_adi, wave_flag) time = 1.0 / abs(wavespeed) for res in (16, 32): arguments = [ 'time/tlim=' + repr(time), 'time/cfl_number=0.3', 'output1/dt=-1', 'mesh/nx1=' + repr(res), 'mesh/nx2=' + repr(res / 2), 'mesh/nx3=' + repr(res / 2), 'meshblock/nx1=' + repr(res / 2), 'meshblock/nx2=' + repr(res / 2), 'meshblock/nx3=' + repr(res / 2), 'hydro/gamma=' + repr(gamma_adi), 'problem/wave_flag=' + repr(wave_flag), 'problem/compute_error=true', 'problem/rho=' + repr(rho), 'problem/pgas=' + repr(pgas), 'problem/vx=' + repr(vx), 'problem/vy=' + repr(vy), 'problem/vz=' + repr(vz), 'problem/Bx=' + repr(bx), 'problem/By=' + repr(by), 'problem/Bz=' + repr(bz) ] athena.run('mhd_sr/athinput.linear_wave', arguments)
def run(**kwargs): """ Run the executable. This function is called second. It is responsible for calling the Athena++ binary in such a way as to produce testable output. It takes no inputs and produces no outputs. """ # Create list of runtime arguments to override the athinput file. Each element in the # list is simply a string of the form '<block>/<field>=<value>', where the contents of # the string are exactly what one would type on the command line run running Athena++. arguments = [ 'time/ncycle_out=0', 'job/problem_id=gr_shock_tube', 'output1/file_type=vtk', 'output1/variable=cons', 'output1/dt=0.4', 'time/cfl_number=0.4', 'time/tlim=0.4', 'mesh/nx1=400' ] # Run Athena++ as though we called # ./athena -i ../inputs/hydro_sr/athinput.mb_1 job/problem_id=gr_shock_tube <...> # from the bin/ directory. Note we omit the leading '../inputs/' below when specifying # the athinput file.) athena.run('hydro_sr/athinput.mb_1', arguments) # No return statement/value is ever required from run(), but returning anything other # than default None will cause run_tests.py to skip executing the optional Lcov cmd # immediately after this module.run() finishes, e.g. if Lcov was already invoked by: # athena.run('hydro_sr/athinput.mb_1', arguments, lcov_test_suffix='mb_1') return 'skip_lcov'
def run(**kwargs): arguments = ['time/ncycle_out=0', 'time/nlim=80'] athena.run('mhd/athinput.test_outputs', arguments) arguments = ['time/ncycle_out=0', 'time/nlim=330'] athena.restart('TestOutputs.00001.rst', arguments) arguments = ['time/ncycle_out=0', 'time/nlim=-1'] athena.restart('TestOutputs.00004.rst', arguments)
def run(**kwargs): os.system('mv obj_fft obj') os.system('mv bin/athena_fft bin/athena') arguments = [ 'time/ncycle_out=10', 'mesh/nx1=64', 'mesh/nx2=32', 'mesh/nx3=32', 'meshblock/nx1=16', 'meshblock/nx2=16', 'meshblock/nx3=16', 'problem/turb_flag=3', 'turbulence/rseed=1', 'output2/dt=-1', 'time/tlim=0.3' ] athena.run('hydro/athinput.turb', arguments + ['job/problem_id=turb_serial'], lcov_test_suffix='fft') os.system('mv obj_mpi_fft obj') os.system('mv bin/athena_mpi_fft bin/athena') athena.mpirun(kwargs['mpirun_cmd'], kwargs['mpirun_opts'], 1, 'hydro/athinput.turb', arguments + ['job/problem_id=turb_mpi1']) athena.mpirun(kwargs['mpirun_cmd'], kwargs['mpirun_opts'], 2, 'hydro/athinput.turb', arguments + ['job/problem_id=turb_mpi2']) athena.mpirun(kwargs['mpirun_cmd'], kwargs['mpirun_opts'], 4, 'hydro/athinput.turb', arguments + ['job/problem_id=turb_mpi4'], lcov_test_suffix='mpi_fft') return 'skip_lcov'
def run(): arguments = [ '', 'output1/file_type=vtk', 'output1/variable=cons', 'output1/dt=0.4', 'time/cfl_number=0.4', 'time/tlim=0.4', 'mesh/nx1=400' ] for i in range(1, 5): arguments[0] = 'job/problem_id=gr_hydro_shock' + repr(i) athena.run('hydro_sr/athinput.mb_' + repr(i), arguments)
def run(**kwargs): arguments = [ 'time/tlim=0', 'time/ncycle_out=0', 'mesh/nx1={0}'.format(nb1 * nx1), 'mesh/nx2={0}'.format(nx2), 'mesh/nx3={0}'.format(nx3), 'meshblock/nx1={0}'.format(nx1), 'meshblock/nx2={0}'.format(nx2), 'meshblock/nx3={0}'.format(nx3), 'problem/input_filename={0}'.format(filename_input) ] athena.run('mhd/athinput.from_array', arguments)
def run(**kwargs): for flux in _fluxes: move(_exec + '_' + flux, _exec) os.system('mv obj_' + flux + ' obj') for n, test in enumerate(_tests): args = [i + '={0:}'.format(test[i]) for i in test] args += ['job/problem_id=eos_riemann_{0:}_{1:02d}'.format(flux, n), 'time/ncycle_out=0'] athena.run('hydro/athinput.sod_general_H', args)
def run(**kwargs): args = {'time/tlim': '0', 'output2/file_type': 'rst'} for n in _nscalars: move(_exec + '_' + str(n), _exec) os.system('mv obj_' + str(n) + ' obj') athena.run('hydro/athinput.sod', [i + '=' + args[i] for i in args], lcov_test_suffix=str(n)) athena.restart('Sod.00000.rst', [i + '=' + args[i] for i in args]) os.system('rm -rf obj') return 'skip_lcov'
def run(**kwargs): arguments = [ 'job/problem_id=', 'output1/file_type=vtk', 'output1/variable=cons', 'output1/dt=', 'time/tlim=', 'mesh/nx1=', 'time/ncycle_out=100' ] times = [0.4, 0.55, 0.5] zones = [400, 800, 800] for i, time, zone in zip([1, 2, 4], times, zones): arguments_copy = list(arguments) arguments_copy[0] += 'sr_mhd_shock' + repr(i) arguments_copy[3] += repr(time) arguments_copy[4] += repr(time) arguments_copy[5] += repr(zone) athena.run('mhd_sr/athinput.mub_' + repr(i), arguments_copy)
def run(): # L-going fast wave arguments = [ 'problem/wave_flag=0','problem/vflow=0.0','mesh/refinement=static', 'mesh/nx1=32', 'mesh/nx2=16', 'mesh/nx3=16', 'meshblock/nx1=8', 'meshblock/nx2=8', 'meshblock/nx3=8', 'output2/dt=-1', 'time/tlim=2.0', 'problem/compute_error=true'] athena.run('mhd/athinput.linear_wave3d', arguments) os.system('mv bin/athena_mpi bin/athena') athena.mpirun(1, 'mhd/athinput.linear_wave3d', arguments) athena.mpirun(2, 'mhd/athinput.linear_wave3d', arguments) athena.mpirun(4, 'mhd/athinput.linear_wave3d', arguments)
def run(): # run R-going wave at two resolutions for i in (128, 256): arguments = [ 'mesh/refinement=static', 'mesh/nx1=' + repr(i), 'mesh/nx2=' + repr(i / 2), 'meshblock/nx1=' + repr(i / 4), 'meshblock/nx2=' + repr(i / 8), 'output2/dt=-1', 'time/tlim=1.0', 'problem/compute_error=true' ] athena.run('mhd/athinput.cpaw2d', arguments) # run L-going wave arguments = [ 'mesh/refinement=static', 'mesh/nx1=256', 'mesh/nx2=128', 'meshblock/nx1=64', 'meshblock/nx2=32', 'output2/dt=-1', 'time/tlim=1.0', 'problem/compute_error=true', 'problem/dir=2' ] athena.run('mhd/athinput.cpaw2d', arguments)
def run(**kwargs): for coord_ in coords: os.system('mv obj_{} obj'.format(coord_)) os.system('mv bin/athena_{} bin/athena'.format(coord_)) for (case_, case_params) in cases.items(): for (torder, xorder) in solvers: for i, nx_ in enumerate(resolution_range): if i > 0: # take sqrt of geometric mesh spacing factor every time the radial # resolution is doubled: x1rat = np.power(base_x1rat, 0.5**i) else: x1rat = base_x1rat dt_tab = 1.0 if plot_profiles and nx_ == nx1_profile else -1 arguments = [ 'time/ncycle_out=0', 'time/xorder={}'.format(xorder), 'time/integrator={}'.format(torder), 'mesh/nx1={}'.format(nx_), 'mesh/x1rat={}'.format(x1rat), # suppress .hst output, by default 'output1/dt=-1', # .tab output: 'output2/dt={}'.format(dt_tab), 'problem/iprob={}'.format(iprob), 'problem/a_width={}'.format(case_params[0]), 'problem/b_center={}'.format(case_params[1]), 'problem/compute_error=true' ] athena.run('hydro/athinput.mignone_radial', arguments, lcov_test_suffix=coord_) if plot_profiles and nx_ == nx1_profile: tab_file = os.path.join( 'bin', 'MignoneRadial.block0.out2.00001.tab') new_tab_file = os.path.join( 'bin', '{}_case_{}_{}_xorder_{}_nx1_{}.tab'.format( coord_, case_, torder, xorder, nx_)) os.system('mv {} {}'.format(tab_file, new_tab_file)) default_error_file = os.path.join('bin', 'mignone_radial-errors.dat') error_file = os.path.join( 'bin', 'errors_{}_case_{}_{}_xorder_{}.dat'.format( coord_, case_, torder, xorder)) os.system('mv {} {}'.format(default_error_file, error_file)) return 'skip_lcov'
def run(**kwargs): arguments = [ 'job/problem_id=HB3', 'output1/file_type=hst', 'output1/dt=62.831853', 'output2/file_type=vtk', 'output2/variable=prim', 'output2/dt=62831.853', 'time/cfl_number=0.4', 'time/tlim=50265.482', 'time/nlim=500000', 'time/xorder=2', 'time/integrator=vl2', 'time/ncycle_out=10', 'mesh/nx1=64', 'mesh/x1min=-0.5', 'mesh/x1max=0.5', 'mesh/ix1_bc=periodic', 'mesh/ox1_bc=periodic', 'mesh/nx2=64', 'mesh/x2min=-0.5', 'mesh/x2max=0.5', 'mesh/ix2_bc=periodic', 'mesh/ox2_bc=periodic', 'mesh/nx3=1', 'mesh/x3min=-0.5', 'mesh/x3max=0.5', 'hydro/iso_sound_speed=0.00408', 'problem/beta=4000', 'problem/amp=0.01', 'problem/ipert=1', 'problem/ifield=1', 'problem/Omega0=1.0e-3', 'problem/qshear=1.5', 'problem/shboxcoord=2', 'time/ncycle_out=0' ] athena.run('mhd/athinput.hb3', arguments)
def run(**kwargs): for i in resolution_range: arguments0 = [ 'output2/file_type=tab', 'output2/variable=v2', 'output2/data_format=%24.16e', 'output2/dt={}'.format(_t0), 'time/cfl_number=0.8', 'time/tlim={}'.format(_t0), 'time/nlim=500', 'time/ncycle_out=0', 'mesh/nx1=' + repr(i), 'mesh/x1min={}'.format( -_Lx1 / 2.), 'mesh/x1max={}'.format(_Lx1 / 2.), 'mesh/ix1_bc=outflow', 'mesh/ox1_bc=outflow', 'mesh/nx2=1', 'mesh/x2min=-1.0', 'mesh/x2max=1.0', 'mesh/ix2_bc=periodic', 'mesh/ox2_bc=periodic', 'mesh/nx3=1', 'mesh/x3min=-1.0', 'mesh/x3max=1.0', 'mesh/ix3_bc=periodic', 'mesh/ox3_bc=periodic', 'hydro/iso_sound_speed=1.0', 'problem/v0={}'.format(_amp), 'problem/iprob=0', 'problem/nu_iso={}'.format(_nu) ] arguments = arguments0 + ['job/problem_id=visc' + repr(i)] athena.run('hydro/athinput.visc', arguments)
def run(**kwargs): arguments0 = [ 'output1/file_type=hst', 'output1/dt=0.01', 'output2/file_type=vtk', 'output2/variable=prim', 'output2/dt=0.03', 'time/cfl_number=0.3', 'time/tlim=3.0', 'time/nlim=-1', 'time/ncycle_out=0', 'mesh/nx1=64', 'mesh/x1min=0.0', 'mesh/x1max=3.0', 'mesh/ix1_bc=periodic', 'mesh/ox1_bc=periodic', 'mesh/nx2=32', 'mesh/x2min=0.0', 'mesh/x2max=1.5', 'mesh/ix2_bc=periodic', 'mesh/ox2_bc=periodic', 'mesh/nx3=32', 'mesh/x3min=0.0', 'mesh/x3max=1.5', 'mesh/ix3_bc=periodic', 'mesh/ox3_bc=periodic', 'mesh/num_threads=1', 'mesh/refinement=none', 'meshblock/nx1=64', 'meshblock/nx2=32', 'meshblock/nx3=32', 'hydro/gamma=1.666666666666667', 'hydro/iso_sound_speed=1.0', # L-going slow wave 'problem/compute_error=false', 'problem/wave_flag=2', 'problem/amp=1.0e-4', 'problem/vflow=0.0', 'problem/nu_iso=0.01', 'problem/eta_ohm=0.02', 'problem/kappa_iso=0.02' ] arguments = arguments0 + ['job/problem_id=DecayLinWave'] athena.run('mhd/athinput.linear_wave3d', arguments)
def run(**kwargs): arguments = [ 'job/problem_id=HGB', 'output1/file_type=hst', 'output1/dt=0.062831853', 'output2/file_type=vtk', 'output2/variable=prim', 'output2/dt=31.4616', 'time/cfl_number=0.3', 'time/tlim=62.83185', 'time/nlim=10000', 'time/xorder=2', 'time/integrator=vl2', 'time/ncycle_out=10', 'mesh/nx1=32', 'mesh/x1min=-0.5', 'mesh/x1max=0.5', 'mesh/ix1_bc=shear_periodic', 'mesh/ox1_bc=shear_periodic', 'mesh/nx2=24', 'mesh/x2min=-1.57079632679', 'mesh/x2max=1.57079632679', 'mesh/ix2_bc=periodic', 'mesh/ox2_bc=periodic', 'mesh/nx3=32', 'mesh/x3min=-0.5', 'mesh/x3max=0.5', 'mesh/ix3_bc=periodic', 'mesh/ox3_bc=periodic', 'meshblock/nx1=32', 'meshblock/nx2=24', 'meshblock/nx3=32', 'hydro/iso_sound_speed=1.0', 'problem/beta=100', 'problem/amp=0.025', 'problem/ipert=1', 'problem/ifield=1', 'problem/Omega0=1.0', 'problem/qshear=1.5', 'time/ncycle_out=0'] athena.run('mhd/athinput.hgb', arguments)
def run(**kwargs): os.system('mv obj_fft obj') os.system('mv bin/athena_fft bin/athena') athena.run('hydro/athinput.fft', ['job/problem_id=fft_serial'], lcov_test_suffix='fft') os.system('mv obj_mpi_fft obj') os.system('mv bin/athena_mpi_fft bin/athena') athena.mpirun(kwargs['mpirun_cmd'], kwargs['mpirun_opts'], 1, 'hydro/athinput.fft', ['job/problem_id=fft_mpi1']) athena.mpirun(kwargs['mpirun_cmd'], kwargs['mpirun_opts'], 2, 'hydro/athinput.fft', ['job/problem_id=fft_mpi2']) athena.mpirun(kwargs['mpirun_cmd'], kwargs['mpirun_opts'], 4, 'hydro/athinput.fft', ['job/problem_id=fft_mpi4'], lcov_test_suffix='mpi_fft') return 'skip_lcov'
def run(**kwargs): # njeans = 1.5 # period = 0.3 # 1/omega = 0.046 # amp 1e-6 def arg_res(res): arguments = [ 'mesh/nx1=64', 'mesh/nx2=32', 'mesh/nx3=32', 'meshblock/nx1=16', 'meshblock/nx2=16', 'meshblock/nx3=16', 'problem/njeans=1.5', 'output2/dt=-1', 'time/tlim=0.046', 'problem/compute_error=true', 'time/ncycle_out=10' ] arguments[0] = 'mesh/nx1=' + str(2 * res) arguments[1] = 'mesh/nx2=' + str(res) arguments[2] = 'mesh/nx3=' + str(res) return arguments athena.run('hydro/athinput.jeans_3d', arg_res(32)) athena.run('hydro/athinput.jeans_3d', arg_res(64))
def run(): wavespeeds = wavespeeds_hydro() for wave_flag in wave_flags: time = 1.0 / abs(wavespeeds[wave_flag]) arguments = [ 'job/problem_id=sr_hydro_wave_{0}_low'.format(wave_flag), 'mesh/nx1=' + repr(res_low), 'meshblock/nx1=' + repr(res_low), 'time/tlim=' + repr(time), 'output1/dt=' + repr(time), 'hydro/gamma=' + repr(gamma_adi), 'problem/rho=' + repr(rho), 'problem/pgas=' + repr(pgas), 'problem/vx=' + repr(vx), 'problem/vy=' + repr(vy), 'problem/vz=' + repr(vz), 'problem/wave_flag=' + repr(wave_flag), 'problem/amp=' + repr(amp) ] athena.run('hydro_sr/athinput.linear_wave', arguments) arguments[0] = 'job/problem_id=sr_hydro_wave_{0}_high'.format( wave_flag) arguments[1] = 'mesh/nx1=' + repr(res_high) arguments[2] = 'meshblock/nx1=' + repr(res_high) athena.run('hydro_sr/athinput.linear_wave', arguments)
def run(**kwargs): for integrator in sts_integrators: for n in resolution_range: arguments = [ 'job/problem_id=ViscousDiffusion_' + repr(n) + '_' + integrator, 'output2/file_type=tab', 'output2/variable=v2', 'output2/data_format=%24.16e', 'output2/dt={}'.format(_tf), 'time/cfl_number=0.8', 'time/tlim={}'.format(_tf), 'time/nlim=10000', 'time/sts_integrator={}'.format(integrator), 'time/ncycle_out=0', 'mesh/nx1=' + repr(n), 'mesh/x1min={}'.format(-_Lx1 / 2.), 'mesh/x1max={}'.format( _Lx1 / 2.), 'mesh/ix1_bc=outflow', 'mesh/ox1_bc=outflow', 'mesh/nx2=1', 'mesh/x2min=-1.0', 'mesh/x2max=1.0', 'mesh/ix2_bc=periodic', 'mesh/ox2_bc=periodic', 'mesh/nx3=1', 'mesh/x3min=-1.0', 'mesh/x3max=1.0', 'mesh/ix3_bc=periodic', 'mesh/ox3_bc=periodic', 'hydro/iso_sound_speed=1.0', 'problem/amp={}'.format(_amp), 'problem/iprob=0', 'problem/t0={}'.format(_t0), 'problem/nu_iso={}'.format(_nu) ] athena.run('hydro/athinput.visc', arguments)
def run(**kwargs): for i in resolution_range: arguments = [ 'output1/dt=0.03', 'output2/dt=-1', # disable .vtk outputs 'time/tlim=3.0', 'time/ncycle_out=0', # L-going sound wave 'problem/wave_flag=0', 'problem/amp=1.0e-4', 'problem/vflow=0.0', 'problem/kappa_iso=0.04', 'mesh/nx1=' + repr(i), 'mesh/nx2=' + repr(i / 2), 'mesh/nx3=' + repr(i / 2), 'meshblock/nx1=' + repr(i), 'meshblock/nx2=' + repr(i / 2), 'meshblock/nx3=' + repr(i / 2), 'job/problem_id=DecayLinWave-{}'.format(i) ] athena.run('hydro/athinput.linear_wave3d', arguments)
def run(**kwargs): # L-going sound wave for i in (32, 64): arguments = [ 'time/ncycle_out=0', 'problem/wave_flag=0', 'problem/vflow=0.0', 'mesh/refinement=static', 'mesh/nx1=' + repr(i), 'mesh/nx2=' + repr(i / 2), 'mesh/nx3=' + repr(i / 2), 'meshblock/nx1=' + repr(i / 4), 'meshblock/nx2=' + repr(i / 4), 'meshblock/nx3=' + repr(i / 4), 'output2/dt=-1', 'time/tlim=1.0', 'problem/compute_error=true' ] athena.run('hydro/athinput.linear_wave3d', arguments) # entropy wave for i in (32, 64): arguments = [ 'time/ncycle_out=0', 'problem/wave_flag=3', 'problem/vflow=1.0', 'mesh/refinement=static', 'mesh/nx1=' + repr(i), 'mesh/nx2=' + repr(i / 2), 'mesh/nx3=' + repr(i / 2), 'meshblock/nx1=' + repr(i / 4), 'meshblock/nx2=' + repr(i / 4), 'meshblock/nx3=' + repr(i / 4), 'output2/dt=-1', 'time/tlim=1.0', 'problem/compute_error=true' ] athena.run('hydro/athinput.linear_wave3d', arguments) # L/R-going sound wave, no SMR for w in (0, 4): arguments = [ 'time/ncycle_out=0', 'problem/wave_flag=' + repr(w), 'output2/dt=-1', 'time/tlim=1.0', 'problem/compute_error=true' ] athena.run('hydro/athinput.linear_wave3d', arguments)
def run(): #case 1 arguments = [ 'problem/er=10.0', 'problem/tgas=1.0', 'problem/sigma=1.0', 'radiation/Prat=0.01', 'radiation/Crat=10.0' ] athena.run('radiation/athinput.thermal_relaxation', arguments) bashcommand = "mv bin/thermal.hst bin/thermal1.hst" os.system(bashcommand) #case 2 arguments = [ 'problem/er=10.0', 'problem/tgas=1.0', 'problem/sigma=100.0', 'radiation/Prat=100.0', 'radiation/Crat=10.0' ] athena.run('radiation/athinput.thermal_relaxation', arguments) bashcommand = "mv bin/thermal.hst bin/thermal2.hst" os.system(bashcommand) #case 3 arguments = [ 'problem/er=1.0', 'problem/tgas=10.0', 'problem/sigma=100.0', 'radiation/Prat=1.0', 'radiation/Crat=10.0' ] athena.run('radiation/athinput.thermal_relaxation', arguments) bashcommand = "mv bin/thermal.hst bin/thermal3.hst" os.system(bashcommand)
def run(**kwargs): # w/o Orbital Advection arguments = [ 'job/problem_id=JGG', 'output1/file_type=hst', 'output1/dt=0.01', 'output1/data_format=%1.16f', 'output2/file_type=vtk', 'output2/variable=prim', 'output2/dt=-1.0', 'time/cfl_number=0.3', 'time/tlim=3.0', 'time/nlim=1000', 'time/xorder=3', 'time/integrator=vl2', 'mesh/nx1=32', 'mesh/x1min=-0.25', 'mesh/x1max=0.25', 'mesh/ix1_bc=shear_periodic', 'mesh/ox1_bc=shear_periodic', 'mesh/nx2=16', 'mesh/x2min=-0.25', 'mesh/x2max=0.25', 'mesh/ix2_bc=periodic', 'mesh/ox2_bc=periodic', 'mesh/nx3=16', 'mesh/x3min=-0.25', 'mesh/x3max=0.25', 'mesh/ix3_bc=periodic', 'mesh/ox3_bc=periodic', 'hydro/iso_sound_speed=1.0', 'problem/d0=1.0', 'problem/amp=1.0e-6', 'problem/beta=20.0', 'problem/ipert=2', 'problem/nwx=-2', 'problem/nwy=1', 'problem/nwz=1', 'orbital_advection/Omega0=1.0', 'orbital_advection/qshear=1.5', 'orbital_advection/OAorder=0', 'problem/error_output=true', 'time/ncycle_out=0' ] athena.run('mhd/athinput.jgg', arguments) # w/ Orbital Advection arguments = [ 'job/problem_id=JGG_ORB', 'output1/file_type=hst', 'output1/dt=0.01', 'output1/data_format=%1.16f', 'output2/file_type=vtk', 'output2/variable=prim', 'output2/dt=-1.0', 'time/cfl_number=0.3', 'time/tlim=3.0', 'time/nlim=1000', 'time/xorder=3', 'time/integrator=vl2', 'mesh/nx1=32', 'mesh/x1min=-0.25', 'mesh/x1max=0.25', 'mesh/ix1_bc=shear_periodic', 'mesh/ox1_bc=shear_periodic', 'mesh/nx2=16', 'mesh/x2min=-0.25', 'mesh/x2max=0.25', 'mesh/ix2_bc=periodic', 'mesh/ox2_bc=periodic', 'mesh/nx3=16', 'mesh/x3min=-0.25', 'mesh/x3max=0.25', 'mesh/ix3_bc=periodic', 'mesh/ox3_bc=periodic', 'hydro/iso_sound_speed=1.0', 'problem/d0=1.0', 'problem/amp=1.0e-6', 'problem/beta=20.0', 'problem/ipert=2', 'problem/nwx=-2', 'problem/nwy=1', 'problem/nwz=1', 'orbital_advection/Omega0=1.0', 'orbital_advection/qshear=1.5', 'orbital_advection/OAorder=2', 'problem/error_output=true', 'time/ncycle_out=0' ] athena.run('mhd/athinput.jgg', arguments)
def run(): # run in X1 direction for i in (128, 256): arguments = [ 'mesh/nx1=' + repr(i), 'mesh/nx2=1', 'mesh/nx3=1', 'mesh/ix1_bc=outflow', 'mesh/ox1_bc=outflow', 'mesh/ix2_bc=periodic', 'mesh/ox2_bc=periodic', 'mesh/ix3_bc=periodic', 'mesh/ox3_bc=periodic', 'time/cfl_number=0.3', 'problem/shock_dir=1', 'problem/compute_error=true' ] athena.run('hydro/athinput.sod', arguments) # run in X2 direction for i in (128, 256): arguments = [ 'mesh/nx1=4', 'mesh/nx2=' + repr(i), 'mesh/nx3=1', 'mesh/ix1_bc=periodic', 'mesh/ox1_bc=periodic', 'mesh/ix2_bc=outflow', 'mesh/ox2_bc=outflow', 'mesh/ix3_bc=periodic', 'mesh/ox3_bc=periodic', 'time/cfl_number=0.3', 'problem/shock_dir=2', 'problem/compute_error=true' ] athena.run('hydro/athinput.sod', arguments) # run in X3 direction for i in (128, 256): arguments = [ 'mesh/nx1=4', 'mesh/nx2=4', 'mesh/nx3=' + repr(i), 'mesh/ix1_bc=periodic', 'mesh/ox1_bc=periodic', 'mesh/ix2_bc=periodic', 'mesh/ox2_bc=periodic', 'mesh/ix3_bc=outflow', 'mesh/ox3_bc=outflow', 'time/cfl_number=0.3', 'problem/shock_dir=3', 'problem/compute_error=true' ] athena.run('hydro/athinput.sod', arguments)
def run(**kwargs): # L-going fast/Alfven/slow waves for w in (0, 1, 2): tlim = max(0.5, w) for i in (32, 64): arguments = [ 'time/ncycle_out=0', 'problem/wave_flag=' + repr(w), 'problem/vflow=0.0', 'mesh/refinement=static', 'mesh/nx1=' + repr(i), 'mesh/nx2=' + repr(i / 2), 'mesh/nx3=' + repr(i / 2), 'meshblock/nx1=' + repr(i / 4), 'meshblock/nx2=' + repr(i / 4), 'meshblock/nx3=' + repr(i / 4), 'output2/dt=-1', 'time/tlim=' + repr(tlim), 'problem/compute_error=true' ] athena.run('mhd/athinput.linear_wave3d', arguments) # entropy wave for i in (32, 64): arguments = [ 'time/ncycle_out=0', 'problem/wave_flag=3', 'problem/vflow=1.0', 'mesh/refinement=static', 'mesh/nx1=' + repr(i), 'mesh/nx2=' + repr(i / 2), 'mesh/nx3=' + repr(i / 2), 'meshblock/nx1=' + repr(i / 4), 'meshblock/nx2=' + repr(i / 4), 'meshblock/nx3=' + repr(i / 4), 'output2/dt=-1', 'time/tlim=1.0', 'problem/compute_error=true' ] athena.run('mhd/athinput.linear_wave3d', arguments) # L/R-going fast wave for w in (0, 6): arguments = [ 'time/ncycle_out=0', 'problem/wave_flag=' + repr(w), 'output2/dt=-1', 'time/tlim=0.5', 'problem/compute_error=true' ] athena.run('mhd/athinput.linear_wave3d', arguments)