def simulate_beam_focusing( z_injection_plane, write_dir ):
"""
Simulate a focusing beam in the boosted frame
Parameters
----------
z_injection_plane: float or None
when this is not None, the injection through a plane is
activated.
write_dir: string
The directory where the boosted diagnostics are written.
"""
# Initialize the simulation object
sim = Simulation( Nz, zmax, Nr, rmax, Nm, dt, zmin=zmin,
gamma_boost=gamma_boost, boundaries='open',
use_cuda=use_cuda, v_comoving=v_comoving )
# Note: no macroparticles get created because we do not pass
# the density and number of particle per cell
# Remove the plasma particles
sim.ptcl = []
# Initialize the bunch, along with its space charge
add_elec_bunch_gaussian( sim, sigma_r, sigma_z, n_emit, gamma0,
sigma_gamma, Q, N, tf=(z_focus-z0)/c, zf=z_focus, boost=boost,
z_injection_plane=z_injection_plane )
# Configure the moving window
sim.set_moving_window( v=c )
# Add a field diagnostic
sim.diags = [
BackTransformedParticleDiagnostic( zmin, zmax, c, dt_snapshot_lab,
Ntot_snapshot_lab, gamma_boost, period=100, fldobject=sim.fld,
species={'bunch':sim.ptcl[0]}, comm=sim.comm, write_dir=write_dir)
]
# Run the simulation
sim.step( N_step )
# Diagnostics in the lab frame (back-transformed)
BackTransformedFieldDiagnostic(zmin,
zmax,
v_window,
dt_lab_diag_period,
N_lab_diag,
boost.gamma0,
fieldtypes=['rho', 'E', 'B'],
period=write_period,
fldobject=sim.fld,
comm=sim.comm),
BackTransformedParticleDiagnostic(zmin,
zmax,
v_window,
dt_lab_diag_period,
N_lab_diag,
boost.gamma0,
write_period,
sim.fld,
select={'uz': [0., None]},
species={'bunch': bunch},
comm=sim.comm)
]
# Number of iterations to perform
N_step = int(T_interact / sim.dt)
### Run the simulation
sim.step(N_step)
print('')
def run_simulation(gamma_boost, use_separate_electron_species):
"""
Run a simulation with a laser pulse going through a gas jet of ionizable
N5+ atoms, and check the fraction of atoms that are in the N5+ state.
Parameters
----------
gamma_boost: float
The Lorentz factor of the frame in which the simulation is carried out.
use_separate_electron_species: bool
Whether to use separate electron species for each level, or
a single electron species for all levels.
"""
# The simulation box
zmax_lab = 20.e-6 # Length of the box along z (meters)
zmin_lab = 0.e-6
Nr = 3 # Number of gridpoints along r
rmax = 10.e-6 # Length of the box along r (meters)
Nm = 2 # Number of modes used
# The particles of the plasma
p_zmin = 5.e-6 # Position of the beginning of the plasma (meters)
p_zmax = 15.e-6
p_rmin = 0. # Minimal radial position of the plasma (meters)
p_rmax = 100.e-6 # Maximal radial position of the plasma (meters)
n_atoms = 0.2 # The atomic density is chosen very low,
# to avoid collective effects
p_nz = 2 # Number of particles per cell along z
p_nr = 1 # Number of particles per cell along r
p_nt = 4 # Number of particles per cell along theta
# Boosted frame
boost = BoostConverter(gamma_boost)
# Boost the different quantities
beta_boost = np.sqrt(1. - 1. / gamma_boost**2)
zmin, zmax = boost.static_length([zmin_lab, zmax_lab])
p_zmin, p_zmax = boost.static_length([p_zmin, p_zmax])
n_atoms, = boost.static_density([n_atoms])
# Increase the number of particles per cell in order to keep sufficient
# statistics for the evaluation of the ionization fraction
if gamma_boost > 1:
p_nz = int(2 * gamma_boost * (1 + beta_boost) * p_nz)
# The laser
a0 = 1.8 # Laser amplitude
lambda0_lab = 0.8e-6 # Laser wavelength
# Boost the laser wavelength before calculating the laser amplitude
lambda0, = boost.copropag_length([lambda0_lab], beta_object=1.)
# Duration and initial position of the laser
ctau = 10. * lambda0
z0 = -2 * ctau
# Calculate laser amplitude
omega = 2 * np.pi * c / lambda0
E0 = a0 * m_e * c * omega / e
B0 = E0 / c
def laser_func(F, x, y, z, t, amplitude, length_scale):
"""
Function that describes a Gaussian laser with infinite waist
"""
return( F + amplitude * math.cos( 2*np.pi*(z-c*t)/lambda0 ) * \
math.exp( - (z - c*t - z0)**2/ctau**2 ) )
# Resolution and number of timesteps
dz = lambda0 / 16.
dt = dz / c
Nz = int((zmax - zmin) / dz) + 1
N_step = int(
(2. * 40. * lambda0 + zmax - zmin) / (dz * (1 + beta_boost))) + 1
# Get the speed of the plasma
uz_m, = boost.longitudinal_momentum([0.])
v_plasma, = boost.velocity([0.])
# The diagnostics
diag_period = N_step - 1 # Period of the diagnostics in number of timesteps
# Initial ionization level of the Nitrogen atoms
level_start = 2
# Initialize the simulation object, with the neutralizing electrons
# No particles are created because we do not pass the density
sim = Simulation(Nz,
zmax,
Nr,
rmax,
Nm,
dt,
zmin=zmin,
v_comoving=v_plasma,
use_galilean=False,
boundaries='open',
use_cuda=use_cuda)
# Add the charge-neutralizing electrons
elec = sim.add_new_species(q=-e,
m=m_e,
n=level_start * n_atoms,
p_nz=p_nz,
p_nr=p_nr,
p_nt=p_nt,
p_zmin=p_zmin,
p_zmax=p_zmax,
p_rmin=p_rmin,
p_rmax=p_rmax,
continuous_injection=False,
uz_m=uz_m)
# Add the N atoms
ions = sim.add_new_species(q=0,
m=14. * m_p,
n=n_atoms,
p_nz=p_nz,
p_nr=p_nr,
p_nt=p_nt,
p_zmin=p_zmin,
p_zmax=p_zmax,
p_rmin=p_rmin,
p_rmax=p_rmax,
continuous_injection=False,
uz_m=uz_m)
# Add the target electrons
if use_separate_electron_species:
# Use a dictionary of electron species: one per ionizable level
target_species = {}
level_max = 6 # N can go up to N7+, but here we stop at N6+
for i_level in range(level_start, level_max):
target_species[i_level] = sim.add_new_species(q=-e, m=m_e)
else:
# Use the pre-existing, charge-neutralizing electrons
target_species = elec
level_max = None # Default is going up to N7+
# Define ionization
ions.make_ionizable(element='N',
level_start=level_start,
level_max=level_max,
target_species=target_species)
# Set the moving window
sim.set_moving_window(v=v_plasma)
# Add a laser to the fields of the simulation (external fields)
sim.external_fields = [
ExternalField(laser_func, 'Ex', E0, 0.),
ExternalField(laser_func, 'By', B0, 0.)
]
# Add a particle diagnostic
sim.diags = [
ParticleDiagnostic(
diag_period,
{"ions": ions},
particle_data=["position", "gamma", "weighting", "E", "B"],
# Test output of fields and gamma for standard
# (non-boosted) particle diagnostics
write_dir='tests/diags',
comm=sim.comm)
]
if gamma_boost > 1:
T_sim_lab = (2. * 40. * lambda0_lab + zmax_lab - zmin_lab) / c
sim.diags.append(
BackTransformedParticleDiagnostic(zmin_lab,
zmax_lab,
v_lab=0.,
dt_snapshots_lab=T_sim_lab / 2.,
Ntot_snapshots_lab=3,
gamma_boost=gamma_boost,
period=diag_period,
fldobject=sim.fld,
species={"ions": ions},
comm=sim.comm,
write_dir='tests/lab_diags'))
# Run the simulation
sim.step(N_step, use_true_rho=True)
# Check the fraction of N5+ ions at the end of the simulation
w = ions.w
ioniz_level = ions.ionizer.ionization_level
# Get the total number of N atoms/ions (all ionization levels together)
ntot = w.sum()
# Get the total number of N5+ ions
n_N5 = w[ioniz_level == 5].sum()
# Get the fraction of N5+ ions, and check that it is close to 0.32
N5_fraction = n_N5 / ntot
print('N5+ fraction: %.4f' % N5_fraction)
assert ((N5_fraction > 0.30) and (N5_fraction < 0.34))
# When different electron species are created, check the fraction of
# each electron species
if use_separate_electron_species:
for i_level in range(level_start, level_max):
n_N = w[ioniz_level == i_level].sum()
assert np.allclose(target_species[i_level].w.sum(), n_N)
# Check consistency in the regular openPMD diagnostics
ts = OpenPMDTimeSeries('./tests/diags/hdf5/')
last_iteration = ts.iterations[-1]
w, q = ts.get_particle(['w', 'charge'],
species="ions",
iteration=last_iteration)
# Check that the openPMD file contains the same number of N5+ ions
n_N5_openpmd = np.sum(w[(4.5 * e < q) & (q < 5.5 * e)])
assert np.isclose(n_N5_openpmd, n_N5)
# Remove openPMD files
shutil.rmtree('./tests/diags/')
# Check consistency of the back-transformed openPMD diagnostics
if gamma_boost > 1.:
ts = OpenPMDTimeSeries('./tests/lab_diags/hdf5/')
last_iteration = ts.iterations[-1]
w, q = ts.get_particle(['w', 'charge'],
species="ions",
iteration=last_iteration)
# Check that the openPMD file contains the same number of N5+ ions
n_N5_openpmd = np.sum(w[(4.5 * e < q) & (q < 5.5 * e)])
assert np.isclose(n_N5_openpmd, n_N5)
# Remove openPMD files
shutil.rmtree('./tests/lab_diags/')
def add_diagnostic(self, diagnostic):
# Call method of parent class
PICMI_Simulation.add_diagnostic(self, diagnostic)
# Handle iteration_min/max in regular diagnostic
if type(diagnostic) in [
PICMI_FieldDiagnostic, PICMI_ParticleDiagnostic
]:
if diagnostic.step_min is None:
iteration_min = 0
else:
iteration_min = diagnostic.step_min
if diagnostic.step_max is None:
iteration_max = np.inf
else:
iteration_max = diagnostic.step_max
# Register field diagnostic
if type(diagnostic) in [
PICMI_FieldDiagnostic, PICMI_LabFrameFieldDiagnostic
]:
if diagnostic.data_list is None:
data_list = ['rho', 'E', 'B', 'J']
else:
data_list = set() # Use set to avoid redundancy
for data in diagnostic.data_list:
if data in ['Ex', 'Ey', 'Ez', 'E']:
data_list.add('E')
elif data in ['Bx', 'By', 'Bz', 'B']:
data_list.add('B')
elif data in ['Jx', 'Jy', 'Jz', 'J']:
data_list.add('J')
elif data == 'rho':
data_list.add('rho')
data_list = list(data_list)
if type(diagnostic) == PICMI_FieldDiagnostic:
diag = FieldDiagnostic(period=diagnostic.period,
fldobject=self.fbpic_sim.fld,
comm=self.fbpic_sim.comm,
fieldtypes=data_list,
write_dir=diagnostic.write_dir,
iteration_min=iteration_min,
iteration_max=iteration_max)
# Register particle density diagnostic
rho_density_list = []
if diagnostic.data_list is not None:
for data in diagnostic.data_list:
if data.startswith('rho_'):
# particle density diagnostics, rho_speciesname
rho_density_list.append(data)
if rho_density_list:
species_dict = {}
for data in rho_density_list:
sname = data[4:]
for s in self.species:
if s.name == sname:
species_dict[s.name] = s.fbpic_species
pdd_diag = ParticleChargeDensityDiagnostic(
period=diagnostic.period,
sim=self.fbpic_sim,
species=species_dict,
write_dir=diagnostic.write_dir,
iteration_min=iteration_min,
iteration_max=iteration_max)
self.fbpic_sim.diags.append(pdd_diag)
elif type(diagnostic) == PICMI_LabFrameFieldDiagnostic:
diag = BackTransformedFieldDiagnostic(
zmin_lab=diagnostic.grid.lower_bound[1],
zmax_lab=diagnostic.grid.upper_bound[1],
v_lab=c,
dt_snapshots_lab=diagnostic.dt_snapshots,
Ntot_snapshots_lab=diagnostic.num_snapshots,
gamma_boost=self.gamma_boost,
period=100,
fldobject=self.fbpic_sim.fld,
comm=self.fbpic_sim.comm,
fieldtypes=diagnostic.data_list,
write_dir=diagnostic.write_dir)
# Register particle diagnostic
elif type(diagnostic) in [
PICMI_ParticleDiagnostic, PICMI_LabFrameParticleDiagnostic
]:
species_dict = {}
for s in diagnostic.species:
if s.name is None:
raise ValueError('When using a species in a diagnostic, '
'its name must be set.')
species_dict[s.name] = s.fbpic_species
if diagnostic.data_list is None:
data_list = ['position', 'momentum', 'weighting']
else:
data_list = diagnostic.data_list
if type(diagnostic) == PICMI_ParticleDiagnostic:
diag = ParticleDiagnostic(period=diagnostic.period,
species=species_dict,
comm=self.fbpic_sim.comm,
particle_data=data_list,
write_dir=diagnostic.write_dir,
iteration_min=iteration_min,
iteration_max=iteration_max)
else:
diag = BackTransformedParticleDiagnostic(
zmin_lab=diagnostic.grid.lower_bound[1],
zmax_lab=diagnostic.grid.upper_bound[1],
v_lab=c,
dt_snapshots_lab=diagnostic.dt_snapshots,
Ntot_snapshots_lab=diagnostic.num_snapshots,
gamma_boost=self.gamma_boost,
period=100,
fldobject=self.fbpic_sim.fld,
species=species_dict,
comm=self.fbpic_sim.comm,
particle_data=data_list,
write_dir=diagnostic.write_dir)
# Add it to the FBPIC simulation
self.fbpic_sim.diags.append(diag)
def test_boosted_output(gamma_boost=10.):
"""
# TODO
Parameters
----------
gamma_boost: float
The Lorentz factor of the frame in which the simulation is carried out.
"""
# The simulation box
Nz = 500 # Number of gridpoints along z
zmax_lab = 0.e-6 # Length of the box along z (meters)
zmin_lab = -20.e-6
Nr = 10 # Number of gridpoints along r
rmax = 10.e-6 # Length of the box along r (meters)
Nm = 2 # Number of modes used
# Number of timesteps
N_steps = 500
diag_period = 20 # Period of the diagnostics in number of timesteps
dt_lab = (zmax_lab - zmin_lab) / Nz * 1. / c
T_sim_lab = N_steps * dt_lab
# Move into directory `tests`
os.chdir('./tests')
# Initialize the simulation object
sim = Simulation(
Nz,
zmax_lab,
Nr,
rmax,
Nm,
dt_lab,
0,
0, # No electrons get created because we pass p_zmin=p_zmax=0
0,
rmax,
1,
1,
4,
n_e=0,
zmin=zmin_lab,
initialize_ions=False,
gamma_boost=gamma_boost,
v_comoving=-0.9999 * c,
boundaries='open',
use_cuda=use_cuda)
sim.set_moving_window(v=c)
# Remove the electron species
sim.ptcl = []
# Add a Gaussian electron bunch
# Note: the total charge is 0 so all fields should remain 0
# throughout the simulation. As a consequence, the motion of the beam
# is a mere translation.
N_particles = 3000
add_elec_bunch_gaussian(sim,
sig_r=1.e-6,
sig_z=1.e-6,
n_emit=0.,
gamma0=100,
sig_gamma=0.,
Q=0.,
N=N_particles,
zf=0.5 * (zmax_lab + zmin_lab),
boost=BoostConverter(gamma_boost))
sim.ptcl[0].track(sim.comm)
# openPMD diagnostics
sim.diags = [
BackTransformedParticleDiagnostic(zmin_lab,
zmax_lab,
v_lab=c,
dt_snapshots_lab=T_sim_lab / 3.,
Ntot_snapshots_lab=3,
gamma_boost=gamma_boost,
period=diag_period,
fldobject=sim.fld,
species={"bunch": sim.ptcl[0]},
comm=sim.comm)
]
# Run the simulation
sim.step(N_steps)
# Check consistency of the back-transformed openPMD diagnostics:
# Make sure that all the particles were retrived by checking particle IDs
ts = OpenPMDTimeSeries('./lab_diags/hdf5/')
ref_pid = np.sort(sim.ptcl[0].tracker.id)
for iteration in ts.iterations:
pid, = ts.get_particle(['id'], iteration=iteration)
pid = np.sort(pid)
assert len(pid) == N_particles
assert np.all(ref_pid == pid)
# Remove openPMD files
shutil.rmtree('./lab_diags/')
os.chdir('../')