def numerical_loop(real_time, pos, vel, Ie, W_elec, idx, B, E_int, q_dens, Ji, Ve, Te, DT, max_inc, data_iter, ch_flag): ''' Does the number crunching for a short snippet. Logs number of time variable changes in ch_flag as powers of 2 (-1 = half, 2 = 4 times slower) Array values are mutable: Don't have to be returned. Only integer values ''' qq = 0 while qq < data_iter: # Check timestep used for this iteration vel, qq, DT, max_inc, data_iter, ch_flag = aux.check_timestep( qq, DT, pos, vel, B, E_int, q_dens, Ie, W_elec, max_inc, data_iter, idx) # Add timestep to counter real_time += DT # Main loop pos, vel, Ie, W_elec, q_dens_adv, Ji = particles.advance_particles_and_moments( pos, vel, Ie, W_elec, idx, B, E_int, DT) q_dens = 0.5 * (q_dens + q_dens_adv) B = fields.push_B(B, E_int, DT) E_half, Ve, Te = fields.calculate_E(B, Ji, q_dens) q_dens = q_dens_adv.copy() # Predictor-Corrector: Advance fields to start of next timestep E_int, B = fields.predictor_corrector(B, E_int, E_half, pos, vel, q_dens_adv, Ie, W_elec, idx, DT) # Increment loop variable qq += 1 return DT, ch_flag, max_inc, data_iter, real_time
part = init.initialize_particles() B, E = init.initialize_magnetic_field() DT, max_inc, data_dump_iter, plot_dump_iter = aux.set_timestep(part) if generate_data == 1: pas.store_run_parameters(DT, data_dump_iter) print('Loading initial state...\n') part, dns_int, dns_half, J_plus, J_minus, G, L = sources.init_collect_moments( part, 0.5 * DT) qq = 0 while qq < max_inc: part, qq, DT, max_inc, data_dump_iter, plot_dump_iter, change_flag = aux.check_timestep( qq, DT, part, B, E, dns_int, max_inc, data_dump_iter, plot_dump_iter) if change_flag == 1: print( 'Timestep halved. Syncing particle velocity/position with DT = {}' .format(DT)) part, dns_int, dns_half, J_plus, J_minus, G, L = sources.init_collect_moments( part, 0.5 * DT) B = fields.cyclic_leapfrog(B, dns_int, J_minus, DT) E = fields.calculate_E(B, J_minus, dns_half) J = sources.push_current(J_plus, E, B, L, G, DT) E = fields.calculate_E(B, J, dns_half) part = particles.velocity_update(part, B, E, DT)
DT, max_inc, data_iter = aux.set_timestep(vel) print 'Timestep: %.4fs, %d iterations total' % (DT, max_inc) if generate_data == 1: save.store_run_parameters(DT, data_iter) q_dens, Ji = sources.collect_moments(vel, Ie, W_elec, idx) E_int, Ve, Te = fields.calculate_E(B, Ji, q_dens) vel = particles.velocity_update(pos, vel, Ie, W_elec, idx, B, E_int, -0.5 * DT) qq = 0 while qq < max_inc: # Check timestep vel, qq, DT, max_inc, data_iter, ch_flag \ = aux.check_timestep(qq, DT, pos, vel, B, E_int, q_dens, Ie, W_elec, max_inc, data_iter, idx) if ch_flag == 1: print 'Timestep halved. Syncing particle velocity with DT = {}'.format( DT) elif ch_flag == 2: print 'Timestep Doubled. Syncing particle velocity with DT = {}'.format( DT) # Main loop pos, vel, Ie, W_elec, q_dens_adv, Ji = particles.advance_particles_and_moments( pos, vel, Ie, W_elec, idx, B, E_int, DT) q_dens = 0.5 * (q_dens + q_dens_adv) B = fields.push_B(B, E_int, DT) E_half, Ve, Te = fields.calculate_E(B, Ji, q_dens) q_dens = q_dens_adv.copy()
print('Loading initial state...\n') sources.init_collect_moments(pos, vel, Ie, W_elec, idx, ni_init, nu_init, ni, nu_plus, rho_int, rho_half, J, J_plus, L, G, 0.5 * DT) # Put init into qq = 0 and save as usual, qq = 1 will be at t = dt qq = 0 print('Starting loop...') while qq < max_inc: ############################ ##### EXAMINE TIMESTEP ##### ############################ if adaptive_timestep == 1: qq, DT, max_inc, part_save_iter, field_save_iter, change_flag, subcycles =\ aux.check_timestep(qq, DT, pos, vel, Ie, W_elec, B, E, rho_int, max_inc, part_save_iter, field_save_iter, subcycles) # Collect new moments and desync position and velocity if change_flag == 1: sources.init_collect_moments(pos, vel, Ie, W_elec, idx, ni_init, nu_init, ni, nu_plus, rho_int, rho_half, J, J_plus, L, G, 0.5 * DT) # Debug: Test if everything is the same if J is replaced with J_minus at each loop. # Yes it is after loop 0 and loop 1 up until collect_moments() # Disable this at some point and see if it improves (or even changes) anything. # ============================================================================= # if qq > 0: # J[:, :] = J_minus[:, :] # =============================================================================
B, E = init.initialize_fields() DT, max_inc, part_save_iter, field_save_iter, subcycles = aux.set_timestep(vel) print('Loading initial state...\n') pos, Ie, W_elec, dns_int, dns_half, J_plus, J_minus, G, L = sources.init_collect_moments(pos, vel, Ie, W_elec, idx, 0.5*DT) #J_init?? Should be J qq = 0 print('Starting loop...') while qq < max_inc: #print('Timestep', qq) ############################ ##### EXAMINE TIMESTEP ##### ############################ if adaptive_timestep == 1: pos, qq, DT, max_inc, part_save_iter, field_save_iter, change_flag, subcycles = aux.check_timestep(qq, DT, pos, vel, B, E, dns_int, max_inc, part_save_iter, field_save_iter, subcycles) if change_flag == 1: print('Timestep halved. Syncing particle velocity/position with DT = {}'.format(DT)) pos, Ie, W_elec, dns_int, dns_half, J_plus, J_minus, G, L = sources.init_collect_moments(pos, vel, Ie, W_elec, idx, 0.5*DT) elif change_flag == 2: print('Timestep doubled. Syncing particle velocity/position with DT = {}'.format(DT)) pos, Ie, W_elec, dns_int, dns_half, J_plus, J_minus, G, L = sources.init_collect_moments(pos, vel, Ie, W_elec, idx, 0.5*DT) ####################### ###### MAIN LOOP ###### ####################### B = fields.cyclic_leapfrog(B, dns_int, J_minus, DT, subcycles) E, Ve, Te = fields.calculate_E(B, J_minus, dns_half)
DT, max_inc, data_iter, plot_iter = aux.set_timestep(vel) q_dens, Ji = particles.advance_particles_and_moments( pos, vel, idx, B, E_int, 0) E_int, Ve, Te = fields.calculate_E(B, Ji, q_dens) particles.sync_velocities(pos, vel, idx, B, E_int, -0.5 * DT) qq = 0 max_inc = 10 while qq < max_inc: # TIMESTEP CHECK if adaptive_timestep == True: qq, DT, max_inc, data_iter, plot_iter \ = aux.check_timestep(qq, DT, pos, vel, B, E_int, q_dens, max_inc, data_iter, plot_iter, idx) # MAIN LOOP q_dens_adv, Ji = particles.advance_particles_and_moments( pos, vel, idx, B, E_int, DT) q_dens = 0.5 * (q_dens + q_dens_adv) B = fields.push_B(B, E_int, DT) E_half, Ve, Te = fields.calculate_E(B, Ji, q_dens) q_dens = q_dens_adv.copy() E_int, B = fields.predictor_corrector(B, E_int, E_half, pos, vel, q_dens, idx, DT) # OUTPUT if qq % data_iter == 0 and generate_data == 1:
print('Retarding velocity...') particles.velocity_update(pos, vel, Ie, W_elec, Ib, W_mag, idx, Ep, Bp, B, E_int, v_prime, S, T, temp_N, -0.5 * DT) print('<< Initialization Complete >>\n') if True: qq = 1 sim_time = DT print('Starting main loop...') while qq < max_inc: ########################### ####### MAIN LOOP ######### ########################### # Check timestep qq, DT, max_inc, part_save_iter, field_save_iter, damping_array \ = aux.check_timestep(pos, vel, B, E_int, q_dens, Ie, W_elec, Ib, W_mag, temp3De, Ep, Bp, v_prime, S, T,temp_N,\ qq, DT, max_inc, part_save_iter, field_save_iter, idx, B_damping_array) # Move particles, collect moments, delete or inject new particles particles.advance_particles_and_moments(pos, vel, Ie, W_elec, Ib, W_mag, idx, Ep, Bp, v_prime, S, T,temp_N,\ B, E_int, DT, q_dens_adv, Ji, ni, nu, flux_rem) # Average N, N + 1 densities (q_dens at N + 1/2) q_dens *= 0.5 q_dens += 0.5 * q_dens_adv if disable_waves == False: # Push B from N to N + 1/2 fields.push_B(B, E_int, temp3Db, DT,
if save_fields == 1: save.save_field_data(DT, field_save_iter, 0, Ji, E_int, B, Ve, Te, q_dens) vel = particles.velocity_update(pos, vel, Ie, W_elec, idx, B, E_int, -0.5 * DT) qq = 1 print('Starting main loop...') while qq < max_inc: ############################ ##### EXAMINE TIMESTEP ##### ############################ vel, qq, DT, max_inc, part_save_iter, field_save_iter \ = aux.check_timestep(qq, DT, pos, vel, B, E_int, q_dens, Ie, W_elec, max_inc, part_save_iter, field_save_iter, idx) ####################### ###### MAIN LOOP ###### ####################### pos, vel, Ie, W_elec, q_dens_adv, Ji = particles.advance_particles_and_moments( pos, vel, Ie, W_elec, idx, B, E_int, DT) q_dens = 0.5 * (q_dens + q_dens_adv) B = fields.push_B(B, E_int, DT) E_half, Ve, Te = fields.calculate_E(B, Ji, q_dens) q_dens = q_dens_adv.copy() E_int, B = fields.predictor_corrector(B, E_int, E_half, pos, vel,
pos, vel, Ie, W_elec, idx = init.initialize_particles() B, E = init.initialize_fields() DT, max_inc, data_iter, plot_iter, subcycles = aux.set_timestep(vel) print 'Loading initial state...\n' pos, Ie, W_elec, dns_int, dns_half, J_plus, J_minus, G, L = sources.init_collect_moments(pos, vel, Ie, W_elec, idx, 0.5*DT) qq = 0 while qq < max_inc: ############################ ##### EXAMINE TIMESTEP ##### ############################ if adaptive_timestep == 1: pos, qq, DT, max_inc, data_iter, plot_iter, change_flag, subcycles = aux.check_timestep(qq, DT, pos, vel, B, E, dns_int, max_inc, data_iter, plot_iter, subcycles) if change_flag == 1: print 'Timestep halved. Syncing particle velocity/position with DT = {}'.format(DT) pos, Ie, W_elec, dns_int, dns_half, J_plus, J_minus, G, L = sources.init_collect_moments(pos, vel, Ie, W_elec, idx, 0.5*DT) elif change_flag == 2: print 'Timestep doubled. Syncing particle velocity/position with DT = {}'.format(DT) pos, Ie, W_elec, dns_int, dns_half, J_plus, J_minus, G, L = sources.init_collect_moments(pos, vel, Ie, W_elec, idx, 0.5*DT) ####################### ###### MAIN LOOP ###### ####################### B = fields.cyclic_leapfrog(B, dns_int, J_minus, DT, subcycles) E, Ve, Te = fields.calculate_E(B, J_minus, dns_half) J = sources.push_current(J_plus, E, B, L, G, DT)