def generate_6D_Gaussian_bunch(self, n_macroparticles, intensity, epsn_x, epsn_y, sigma_z): '''Generate a 6D Gaussian distribution of particles which is transversely matched to the Synchrotron. Longitudinally, the distribution is matched only in terms of linear focusing. For a non-linear bucket, the Gaussian distribution is cut along the separatrix (with some margin). It will gradually filament into the bucket. This will change the specified bunch length. ''' if self.longitudinal_mode == 'linear': check_inside_bucket = lambda z,dp : np.array(len(z)*[True]) elif self.longitudinal_mode == 'non-linear': check_inside_bucket = self.longitudinal_map.get_bucket( gamma=self.gamma).make_is_accepted(margin=0.05) else: raise NotImplementedError( 'Something wrong with self.longitudinal_mode') eta = self.longitudinal_map.alpha_array[0] - self.gamma**-2 beta_z = np.abs(eta)*self.circumference/2./np.pi/self.longitudinal_map.Qs sigma_dp = sigma_z/beta_z epsx_geo = epsn_x/self.betagamma epsy_geo = epsn_y/self.betagamma injection_optics = self.transverse_map.get_injection_optics() bunch = gen.ParticleGenerator(macroparticlenumber=n_macroparticles, intensity=intensity, charge=self.charge, mass=self.mass, circumference=self.circumference, gamma=self.gamma, distribution_x = gen.gaussian2D(epsx_geo), alpha_x=injection_optics['alpha_x'], beta_x=injection_optics['beta_x'], D_x=injection_optics['D_x'], distribution_y = gen.gaussian2D(epsy_geo), alpha_y=injection_optics['alpha_y'], beta_y=injection_optics['beta_y'], D_y=injection_optics['D_y'], distribution_z = gen.cut_distribution(gen.gaussian2D_asymmetrical(sigma_u=sigma_z, sigma_up=sigma_dp),is_accepted=check_inside_bucket), ).generate() return bunch
def generate_6D_Gaussian_bunch( self, n_macroparticles, intensity, epsn_x, epsn_y, sigma_z ): """Generate a 6D Gaussian distribution of particles which is transversely matched to the Synchrotron. Longitudinally, the distribution is matched only in terms of linear focusing. For a non-linear bucket, the Gaussian distribution is cut along the separatrix (with some margin). It will gradually filament into the bucket. This will change the specified bunch length. """ if self.longitudinal_mode == "linear": check_inside_bucket = lambda z, dp: np.array(len(z) * [True]) Q_s = self.longitudinal_map.Q_s elif self.longitudinal_mode == "non-linear": bucket = self.longitudinal_map.get_bucket( gamma=self.gamma, mass=self.mass, charge=self.charge ) check_inside_bucket = bucket.make_is_accepted(margin=0.05) Q_s = bucket.Q_s else: raise NotImplementedError("Something wrong with self.longitudinal_mode") eta = self.longitudinal_map.alpha_array[0] - self.gamma ** -2 beta_z = np.abs(eta) * self.circumference / 2.0 / np.pi / Q_s sigma_dp = sigma_z / beta_z epsx_geo = epsn_x / self.betagamma epsy_geo = epsn_y / self.betagamma injection_optics = self.transverse_map.get_injection_optics() bunch = generators.ParticleGenerator( macroparticlenumber=n_macroparticles, intensity=intensity, charge=self.charge, mass=self.mass, circumference=self.circumference, gamma=self.gamma, distribution_x=generators.gaussian2D(epsx_geo), alpha_x=injection_optics["alpha_x"], beta_x=injection_optics["beta_x"], D_x=injection_optics["D_x"], distribution_y=generators.gaussian2D(epsy_geo), alpha_y=injection_optics["alpha_y"], beta_y=injection_optics["beta_y"], D_y=injection_optics["D_y"], distribution_z=generators.cut_distribution( generators.gaussian2D_asymmetrical(sigma_u=sigma_z, sigma_up=sigma_dp), is_accepted=check_inside_bucket, ), ).generate() return bunch
def generate_6D_Gaussian_bunch(self, n_macroparticles, intensity, epsn_x, epsn_y, sigma_z): '''Generate a 6D Gaussian distribution of particles which is transversely matched to the Synchrotron. Longitudinally, the distribution is matched only in terms of linear focusing. For a non-linear bucket, the Gaussian distribution is cut along the separatrix (with some margin). It will gradually filament into the bucket. This will change the specified bunch length. ''' if self.longitudinal_focusing == 'linear': check_inside_bucket = lambda z, dp: np.array(len(z) * [True]) elif self.longitudinal_focusing == 'non-linear': check_inside_bucket = self.longitudinal_map.get_bucket( gamma=self.gamma).make_is_accepted(margin=0.05) else: raise NotImplementedError( 'Something wrong with self.longitudinal_focusing') beta_z = np.abs(self.eta) * self.circumference / 2. / np.pi / self.Q_s sigma_dp = sigma_z / beta_z epsx_geo = epsn_x / self.betagamma epsy_geo = epsn_y / self.betagamma bunch = gen.ParticleGenerator( macroparticlenumber=n_macroparticles, intensity=intensity, charge=self.charge, mass=self.mass, circumference=self.circumference, gamma=self.gamma, distribution_x=gen.gaussian2D(epsx_geo), alpha_x=self.alpha_x[0], beta_x=self.beta_x[0], D_x=self.D_x[0], distribution_y=gen.gaussian2D(epsy_geo), alpha_y=self.alpha_y[0], beta_y=self.beta_y[0], D_y=self.D_y[0], distribution_z=gen.cut_distribution( gen.gaussian2D_asymmetrical(sigma_u=sigma_z, sigma_up=sigma_dp), is_accepted=check_inside_bucket)).generate() return bunch
def characterize_impedances(wake_dipolar_element, wake_quadrupolar_element, n_samples_hh_kk, test_amplitude, intensity, sigma_z, circumference, particle_charge, particle_mass, particle_gamma, z_cut, n_tail_cut, detuning_fit_order): # Build response matrix for dipolar impedance slicer_for_harmonicresponse = UniformBinSlicer(n_samples_hh_kk, z_cuts=(-z_cut, z_cut)) # Make a test bunch (I need only longitudinal profile and energy to be correct) bunch = generators.ParticleGenerator( macroparticlenumber=n_samples_hh_kk * 1000, intensity=intensity, charge=particle_charge, mass=particle_mass, circumference=circumference, gamma=particle_gamma, distribution_x=generators.gaussian2D(1e-9), # Dummy not really used alpha_x=0, beta_x=100, D_x=0., distribution_y=generators.gaussian2D(1e-9), alpha_y=0., beta_y=100., D_y=0., distribution_z=generators.cut_distribution( generators.gaussian2D_asymmetrical(sigma_u=sigma_z, sigma_up=1e-4), is_accepted=(lambda z, dp: np.array(len(z) * [True]))), ).generate() bunch.x *= 0 bunch.xp *= 0 bunch.y *= 0 bunch.yp *= 0 # Generate configurations assert (n_samples_hh_kk % 2 == 0) cos_ampl_list = [] sin_ampl_list = [] n_osc_list = [] for ii in range(n_samples_hh_kk // 2): cos_ampl_list.append(test_amplitude) sin_ampl_list.append(0.) n_osc_list.append(ii) cos_ampl_list.append(0.) sin_ampl_list.append(test_amplitude) n_osc_list.append(ii + 1) # cos_ampl_list = [100*1e-4] # sin_ampl_list = [0] # n_osc_list = [3] # Measure responses x_meas_mat = [] x_mat = [] dpx_mat = [] y_meas_mat = [] y_mat = [] dpy_mat = [] for itest in range(len(cos_ampl_list)): N_oscillations = n_osc_list[itest] sin_amplitude = sin_ampl_list[itest] cos_amplitude = cos_ampl_list[itest] # Recenter all slices slices_set = bunch.get_slices(slicer_for_harmonicresponse, statistics=True) for ii in range(slices_set.n_slices): ix = slices_set.particle_indices_of_slice(ii) if len(ix) > 0: bunch.x[ix] -= np.mean(bunch.x[ix]) bunch.xp[ix] -= np.mean(bunch.xp[ix]) bunch.y[ix] -= np.mean(bunch.y[ix]) bunch.yp[ix] -= np.mean(bunch.yp[ix]) # Get slice centers z_slices = slices_set.z_centers N_slices = len(z_slices) # Get z_step beween slices and define z_range z_step = z_slices[1] - z_slices[0] z_range = z_slices[-1] - z_slices[0] + z_step # Last term is to make # sinusoids numerically # orthogonal # Generate ideal sinusoidal distortion x_y_ideal = (sin_amplitude * np.sin(2 * np.pi * N_oscillations * z_slices / z_range) + cos_amplitude * np.cos(2 * np.pi * N_oscillations * z_slices / z_range)) # Add sinusoidal distortion to particles bunch.x += sin_amplitude * np.sin( 2 * np.pi * N_oscillations * bunch.z / z_range) bunch.x += cos_amplitude * np.cos( 2 * np.pi * N_oscillations * bunch.z / z_range) bunch.y += sin_amplitude * np.sin( 2 * np.pi * N_oscillations * bunch.z / z_range) bunch.y += cos_amplitude * np.cos( 2 * np.pi * N_oscillations * bunch.z / z_range) # Measure bunch.clean_slices() slices_set = bunch.get_slices(slicer_for_harmonicresponse, statistics=True) x_slices = slices_set.mean_x y_slices = slices_set.mean_y int_slices = slices_set.lambda_bins() / qe bunch.clean_slices() # Apply impedance wake_dipolar_element.track(bunch) # Measure kicks bunch.clean_slices() slices_set = bunch.get_slices(slicer_for_harmonicresponse, statistics=True) dpx_slices = slices_set.mean_xp dpy_slices = slices_set.mean_yp # Store results x_mat.append(x_y_ideal.copy()) x_meas_mat.append(x_slices.copy()) dpx_mat.append(dpx_slices.copy()) y_mat.append(x_y_ideal.copy()) y_meas_mat.append(y_slices.copy()) dpy_mat.append(dpy_slices.copy()) x_mat = np.array(x_mat) x_meas_mat = np.array(x_meas_mat) dpx_mat = np.array(dpx_mat) y_mat = np.array(y_mat) y_meas_mat = np.array(y_meas_mat) dpy_mat = np.array(dpy_mat) HH_x = x_mat KK_x = dpx_mat HH_y = y_mat KK_y = dpy_mat if n_tail_cut > 0: KK_x[:, :n_tail_cut] = 0. KK_x[:, -n_tail_cut:] = 0. KK_y[:, :n_tail_cut] = 0. KK_y[:, -n_tail_cut:] = 0. ############################# # Detuning characterization # ############################# if wake_quadrupolar_element is not None: bunch.x *= 0 bunch.xp *= 0 bunch.y *= 0 bunch.yp *= 0 bunch.x += test_amplitude bunch.y += test_amplitude bunch.clean_slices() wake_quadrupolar_element.track(bunch) bunch.clean_slices() slices_set = bunch.get_slices(slicer_for_harmonicresponse, statistics=True) dpx_slices = slices_set.mean_xp dpy_slices = slices_set.mean_yp k_quadx = slices_set.mean_xp / test_amplitude k_quady = slices_set.mean_yp / test_amplitude px = np.polyfit(z_slices, k_quadx, deg=detuning_fit_order) py = np.polyfit(z_slices, k_quady, deg=detuning_fit_order) alpha_Nx = px[::-1] alpha_Ny = py[::-1] wake_characterization = { 'HH_x': HH_x, 'KK_x': KK_x, 'HH_y': HH_y, 'KK_y': KK_y, 'z_slices': z_slices, 'alpha_Nx': alpha_Nx, 'alpha_Ny': alpha_Ny } return wake_characterization