def make_particles(PD):
'''Create test particle array'''
particles = particle_data.particle_data(_PD['n_macro'], _PD['charge'], _PD['mass'], _PD['weight'])
#Add r data - better to use linspace than arange
particles.r = np.linspace(0.1*PD['R'],0.9*PD['R'],particles.np)
particles.pr = -particles.mc * np.linspace(0.1, .5,particles.np)
particles.ell = particles.weight*consts.electron_mass*consts.c*particles.r
#Add z data
particles.z = np.linspace(0.1*PD['Z'],0.9*PD['Z'],particles.np)
particles.pz = particles.mc * np.linspace(0., 10., particles.np)
return particles
def make_particles(PD):
# instantiate particle data
ptcl_data = particle_data.particle_data(PD['num_p'], PD['charge'],
PD['mass'], PD['weight'])
# Add r data - evenly distribute out to r = R
ptcl_data.r = np.arange(0., PD['R'],
PD['R'] / PD['num_p']) + PD['R'] / PD['num_p']
# Add pr and ell data - evenly distribute pr out to PR
ptcl_data.pr = ptcl_data.mc * np.arange(0., PD['PR'],
PD['PR'] / PD['num_p'])
ptcl_data.ell = ptcl_data.r * ptcl_data.pr * .1
# Add z data - evenly distribute out to z = Z/10.
ptcl_data.z = np.linspace(
0, _PD['Z'] / 10., _PD['num_p']) #ptcl_data.z = np.zeros(PD['num_p'])
ptcl_data.pz = ptcl_data.mc * np.arange(0., PD['Z'], PD['Z'] / PD['num_p'])
return ptcl_data
def vary_rz_modes(mode_pair, PD, ns=1e2):
'''
Simulate ns number of steps of size ss using npart particles and a number of modes
specified by mode_pair.
Arguments:
mode_pair (tuple): [n_r,n_z]
PD (dict): dictionary of other fixed parameters
ns (Optional[int]) : number of steps to run. Defaults to 100.
Returns:
timing (float): number of seconds/macroparticle/mode
'''
num_steps = ns
PD['n_r'] = mode_pair[0]
PD['n_z'] = mode_pair[1]
num_modes = mode_pair[0] + mode_pair[1]
PD['n_macro'] = PD['np_mode'] * num_modes
num_particles = PD['n_macro']
PD['weight'] = PD['n_e'] / PD['n_macro']
# create fields, particles, integrator
particles = particle_data.particle_data(PD['n_macro'], PD['charge'],
PD['mass'], PD['weight'])
fields = field_data.field_data(PD['Z'], PD['R'], PD['n_z'], PD['n_r'])
create_init_conds(particles, fields, PD)
my_integrator = integrator.integrator(PD['dt'], fields)
step = 0
#print "Running {} total modes and {} particles".format(num_modes, num_particles)
#t0 = time.time()
while step < num_steps:
my_integrator.second_order_step(particles, fields)
step = step + 1
return
from rssympim.sympim_rz.data import particle_data, field_data
from rssympim.sympim_rz.integrators import integrator
import numpy as np
from matplotlib import pyplot as plt
import time
n_ptcls = 1000
n_r = 10
n_z = 10
ptcl_data = particle_data.particle_data(n_ptcls, 1., 1.3, 33.5)
fld_data = field_data.field_data(5., 2., n_r, n_z)
fld_data.mode_coords = np.ones((n_r, n_z, 2))
ptcl_data.r = np.ones(n_ptcls)
for idx in range(0, n_ptcls):
ptcl_data.r[idx] *= idx*(4.)/n_ptcls + .01
ptcl_data.pr = ptcl_data.mc*np.arange(0.,.5,.5/n_ptcls)
ptcl_data.ell = ptcl_data.r*ptcl_data.pr*.1
ptcl_data.z = np.zeros(n_ptcls)
ptcl_data.pz = ptcl_data.mc*np.arange(0.,10.,10./n_ptcls)
dt = .1/np.amax(fld_data.omega)
my_integrator = integrator.integrator(dt, fld_data)
l_r = plasma_widths*2.*np.pi/k_p # cm l_z = plasma_lengths*2.*np.pi/k_p # cm volume = np.pi*l_r*l_r*l_z # Domain parameters n_electrons = n0*volume # Simulation parameters n_r_modes = plasma_widths*modes_per_r n_z_modes = plasma_lengths*modes_per_z n_macro_ptcls = ppm*n_r_modes*n_z_modes macro_weight = n_electrons/n_macro_ptcls # Create simulation objects ptcl_data = particle_data.particle_data(n_macro_ptcls, charge, mass, macro_weight) fld_data = field_data.field_data(l_z, l_r, n_z_modes, n_r_modes) # Ten steps per fastest frequency dt = 0.1*2*np.pi/np.amax(fld_data.omega) # run for ten plasma periods run_time = 50*dt #4.*np.pi/k_p # Set the diagnostics compute_energy = False my_integrator = integrator.integrator(dt, fld_data.omega) # Initial conditions for ptcl_idx in range(0, n_macro_ptcls):
from rssympim.sympim_rz.data import field_data, particle_data
from rssympim.sympim_rz.integrators import integrator
import numpy as np
import timeit
n_ptcls = 40000
n_r = 40
n_z = 100
my_fields = field_data.field_data(1., 1., n_r, n_z)
my_ptcls = particle_data.particle_data(n_ptcls, 1., 1., 1.)
my_ptcls.r = np.ones(n_ptcls)
for idx in range(0, n_ptcls):
my_ptcls.r[idx] *= idx * (4.) / n_ptcls + .01
my_ptcls.pr = -my_ptcls.mc * np.arange(0., .5, .5 / n_ptcls)
my_ptcls.ell = my_ptcls.r * my_ptcls.pr
my_ptcls.z = np.zeros(n_ptcls)
my_ptcls.pz = my_ptcls.mc * np.arange(0., 10., 10. / n_ptcls)
my_integrator = integrator.integrator(.01, my_fields.omega)
my_time = timeit.timeit('my_integrator.single_step(my_ptcls, my_fields)')
print my_time
#######################
# Import the particle and field initial conditions
ptcl_io = particle_io.particle_io('electrons')
fld_io = field_io.field_io('fields')
#
# Create the particle and field data classes
#
# particle data first
r, pr, z, pz, pl, weight, charge, mass = \
ptcl_io.read_ptcls(particle_file)
n_macro = np.shape(r)[0]
electrons = particle_data.particle_data(n_macro, charge, mass, weight)
electrons.r = r
electrons.z = z
electrons.pr = pr
electrons.pz = pz
electrons.ell = pl
electrons.weight = weight
# field data second
n_modes_z, n_modes_r, L, R, P_omega, Q_omega, P_dc, Q_dc = \
fld_io.read_field(fields_file)
fields = field_data.field_data(L, R, n_modes_z, n_modes_r)
ind = np.zeros(size)
for i in range(size):
if i < n_left:
inc += 1
end[i] += n_ptcls_per_core * (i + 1)
end[i] += inc
if i + 1 < size:
ind[i + 1] += n_ptcls_per_core * (i + 1)
ind[i + 1] += inc
fld_data = field_data.field_data(length, radius, n_modes_z, n_modes_r)
ptcl_data = particle_data.particle_data(n_ptcls_per_core,
charge,
mass,
macro_weight,
n_total=n_macro_ptcls,
end=end,
ind=ind)
dtau = 0.1 * 2. * np.pi / np.max(fld_data.omega)
# Initial condition for a plasma wave
fld_data.omega_coords[0, 0,
0] = plasma_wave_amplitude * fld_data.mode_mass[0, 0]
# Initial conditions
#np.random.seed(0)
# uniform particle distribution in x, y, z
x = radius * np.random.rand(n_ptcls_per_core)