def get_min_a0(z, U_i, ctau, max_a=10, ion_thres=0.01):
"""
Calculates the lowest value of a0 that is needed for ionization
-INPUT: -z [array]: Array over the laser pulse
-w0 [float]: Waist of the laser in the focus (in microns)
-ctau [float]: Laser duration (in femtoseconds)
-zf [float]: Laser focus (in microns)
-lambda_0 [float]: Laser wavelength (in microns)
-U_i [float]: Ionization energy (in eV)
-energy [float]: Final energy of the ionized electrons (in J)
-max_a [float,opt]: The upper limit for the laser peak a0
-ion_thres [float,opt]: The threshold/ minimum ionization degree
-RETURN: -min_a0 [float]: The lower limit of a0 for ionization
"""
#Calculate the ionization probability
prob = ionization_probability(z, U_i, max_a, ctau)
#Calculate the ionization degree
degree = ionization_degree(z, prob)
#Get the laser envelope
envelope = las.gaussian_a0(z, max_a, ctau)
#Check for which value of a0 the ionization degree is higher than the threshold
for i in range(0, len(degree)):
if degree[i] > ion_thres:
min_a0 = envelope[i]
break
return (min_a0)
def ionization_probability(z, U_i, max_a, ctau, lambda_0=0.8, energy=0):
"""
Calculates the ionization probability in dependence of laser parameters
INPUT: - U_i [float]: Ionization energy of the atom and the ionization level
- energy [float]: Kinetic energy of the ionized electron after ionization (in MeV)
- max_a [float]: Peak a0 of the laser
- z [array]: Array over the laser pulse
- w0 [float]: Waist of the laser in the focus (in microns)
- ctau [float]: Laser duration (in femtoseconds)
- zf [float]: Focus position of the laser (in microns)
- lambda_0 [float]: Laser wavelength (in microns)
- plot [boolean,opt.]: Wether to plot the result
- r [float, opt.]: Radial position of the laser (in microns)
- t [float, opt.]: Temporal position of the laser
RETURN: - prob [array]: Ionization probability
"""
#Constants and important parameters
U_H = 13.6
epsilon_0 = 8.854e-12
lambda_c = const.h / (const.m_e * const.c)
omega_0 = 2 * np.pi * const.c / lambda_0
E_k = (1 / const.e) * (2 * np.pi / lambda_0) * (const.c**2) * const.m_e
#Electrical field of the laser
E_L = las.gaussian_field_envelope(z, max_a, ctau, lambda_0)
#Envelope of the laser
amplitude = las.gaussian_a0(z, max_a, ctau)
#Keldysh parameter
gamma_k = (const.alpha / amplitude) * np.sqrt(U_i / U_H)
#Argument of the exponential function
laser_ion = lambda_0 / lambda_c * amplitude**3 * gamma_k**3 * (
E_k / (np.abs(E_L)))
tunnel_ion = (gamma_k**3 * energy) / (const.hbar * omega_0)
#ADK rate
rate = np.exp(-2 / 3 * (laser_ion + tunnel_ion))
return (rate)
def potentialeq(phi, zz, z, zi, max_a, ctau, n_e):
"""
Non-linear, 1d differential wave-equation
-INPUT: -phi [array]: Potential of the wake
-zz [array]: Array over the plasma target
-zi [integer]: Order of the solution of the wave-equation
-max_a [float]: Peak a0 of the laser
-ctau [float]: Laser duration (in femtoseconds)
-n_e [float]: Max. plasma density (in 1/cm^3)
-RETURN: -potentialeq [array]: Wave-equation of the non-linear, 1D plasma wave
"""
return array([
phi[1],
((1 + las.gaussian_a0(zz, max_a, ctau)**2) /
(2 * (phi[0] + 1)) - 0.5) * (kp(z, n_e)[zi] / 1e6)**2
])
def condition(z, max_a, ctau, lambda_0, n_e):
"""
Calculates the condition for trapping (i.e. H_e < H_s, where H_e = Hamiltonian of the electron and
H_s = Hamiltonian of the separatrix)
-INPUT: -z [array]: Array over the plasma target
-max_a [float]: Peak a0 of the laser
-ctau [float]: Laser duration (in femtoseconds)
-lambda_0 [float]: Laser wavelength (in microns)
-n_e [float]: Max. plasma density (in 1/cm^3)
-RETURN: cond [array]: H_s - H_e
"""
#Calculate the solution of the wave-equation
phi = potential(z, max_a, ctau, n_e)
#Calculate the hamiltonian of the separatrix
right_side = np.sqrt(1 + las.gaussian_a0(z, max_a, ctau)**2) / gammap(
z, max_a, lambda_0, n_e)
#Calculate the hamiltonian of the separatrix
left_side = 1 + get_phi_min(z, max_a, lambda_0, n_e) - phi[3][:, 0]
return (right_side - left_side)
#------------------------------------
#Ionization energy
U_i = ptcl.get_ion_energy(element,ion_level)
#Ionization probability
prob = ion.ionization_probability(zz,a0,w0,ctau,zf,lambda_0,U_i,energy,)
#Ionization degree
degree = ion.ionization_degree(zz,prob)
#Laser field
laser_field = las.gaussian_field(zz, a0,w0,ctau,zf,lambda_0)
#Laser envelope
laser_envelope = las.gaussian_a0(zz, a0,ctau)
#Wakefield
wake = pot.wakefield(zz,a0,ctau,ne)
#Ionization energy distribution
#distribution = ion.ionization_energy_distribution(zz,a0,w0,ctau,zf,lambda_0,U_i,energy_range=(0,5,0.1))
#Critical plasma density
n_c = plsm.get_critical_density(lambda_0*1e-6)
#-------------------
# Print the results
#-------------------
print("")