def create_beam():
pulse_photon_count = model.energy.photon_count(params.lasing_wavelen, params.pulse_energy)
ref_fluence = params.beam_class.ref_fluence(params.beam_radius, pulse_photon_count)
beam = params.beam_class(params.beam_radius, ref_fluence)
return beam
def amplify_train(dirname, num_types, counts, ref_inversion, quiet=False):
if not quiet:
print output.div_line
if not quiet or params.verbose:
print "amplifying pulse train"
active_medium = create_medium(ref_inversion)
input_beam = create_beam()
ref_pulse = create_pulse(active_medium, input_beam, input_beam.rho_ref, input_beam.phi_ref)
pulse_train = create_train(ref_pulse)
int_type, amp_type = num_types
count_rho, count_phi, count_z, count_t = counts
integrator = model.integrator.DomainIntegrator(int_type)
amp = amp_type(active_medium, count_z)
radius = min(active_medium.radius, input_beam.rho_trunc)
Rho = np.linspace(0.0, radius, count_rho)
Phi = np.linspace(0.0, 2.0*math.pi, count_phi)
output_fluence = np.empty((count_rho, count_phi))
max_fluences = np.empty(params.train_pulse_count)
output_photon_counts = np.empty(params.train_pulse_count)
populations = [[None] * count_phi for _ in range(count_rho)]
for m, rho in enumerate(Rho):
for n, phi in enumerate(Phi):
upper = np.vectorize(active_medium.initial_inversion.inversion)(rho, phi, amp.Z)
lower = np.zeros(count_z)
populations[m][n] = (upper, lower)
norm_beam = params.beam_class(params.beam_radius, 1.0)
norm_pulse = create_pulse(active_medium, norm_beam, norm_beam.rho_ref, norm_beam.phi_ref)
amp._init_time(norm_pulse, count_t)
norm_input_density = np.vectorize(norm_pulse.density)(amp.T)
lower_decay = model.amplifier.lower_state_decay(active_medium, pulse_train)
pulse_num_stride = params.pulse_num_stride
for pnum in range(params.train_pulse_count):
if not quiet or params.verbose:
output.show_status((pnum, None), (pulse_num_stride, None), False)
for m, rho in enumerate(Rho):
for n, phi in enumerate(Phi):
input_density = norm_input_density * input_beam.fluence(rho, phi)
density_out, population_final = amp.amplify(rho, phi, None, None, T=amp.T, initial_population=populations[m][n], input_density=input_density)
upper = np.copy(population_final[0])
lower = population_final[1] * lower_decay
populations[m][n] = (upper, lower)
fluence_out = integrator.integrate(amp.T, density_out) * active_medium.light_speed
output_fluence[m, n] = fluence_out
if pnum == 0:
ref_idx = np.unravel_index(output_fluence.argmax(), output_fluence.shape)
ref_output_fluence = np.copy(output_fluence)
max_fluences[pnum] = output_fluence[ref_idx]
output_photon_counts[pnum] = integrator.integrate_base(active_medium, input_beam, Rho, Phi, output_fluence)
del input_density, density_out, population_final, upper, lower
del amp, output_fluence, populations, norm_input_density
if not quiet or params.verbose:
output.show_status((pnum+1, None), (pulse_num_stride, None), True)
if not quiet or params.verbose:
print "processing results"
max_output_fluence = max_fluences[::-1].sum()
max_output_fluence = model.energy.energy(params.lasing_wavelen, max_output_fluence)
del max_fluences
train_output_photon_count = output_photon_counts[::-1].sum()
train_output_energy = model.energy.energy(params.lasing_wavelen, train_output_photon_count)
rel_gain_decrease = 1.0 - output_photon_counts[-1] / output_photon_counts[0]
if not quiet:
if params.graphs:
print output.status_writing
ref_pulse_dir = os.path.join(dirname, output.ref_pulse_rel_path)
dirname = output.init_dir(dirname)
ref_pulse_dir = output.init_dir(ref_pulse_dir)
output.plot_beam(ref_pulse_dir, input_beam, Rho, Phi, ref_output_fluence)
output.plot_train(dirname, input_beam, active_medium, output_photon_counts)
return max_output_fluence, output_photon_counts, train_output_energy, rel_gain_decrease
