def setUp(self):
initial_time = 0
final_time = 1E-3
# Machine and RF parameters
radius = 25
gamma_transition = 4.4 # [1]
C = 2 * np.pi * radius # [m]
momentum_compaction = 1 / gamma_transition**2 # [1]
particle_type = 'proton'
self.ring = Ring(C, momentum_compaction, \
([0, 1E-3], [3.13E8, 3.13E8]), Proton())
self.rf_params = RFStation(self.ring, [1], [1E3], [np.pi], 1)
self.beam = Beam(self.ring, 1, 0)
self.profile = Profile(self.beam)
self.long_tracker = RingAndRFTracker(self.rf_params, self.beam)
self.full_ring = FullRingAndRF([self.long_tracker])
self.n_turns = self.ring.n_turns
self.map_ = [self.full_ring.track, self.profile.track]
self.trackIt = TrackIteration(self.map_)
def run_simple(self):
self.ring = Ring(self.C, self.alpha_0, self.Ek, Proton(), self.N_t,
synchronous_data_type='kinetic energy',
alpha_1=None, alpha_2=None)
self.beam = Beam(self.ring, self.N_p, self.N_b)
self.rf = RFStation(self.ring, 1, 0, np.pi)
original_distribution_dt = np.zeros(self.beam.n_macroparticles)
original_distribution_dE = np.linspace(
-0.1*self.beam.energy,
0.1*self.beam.energy,
self.beam.n_macroparticles)
self.beam.dt[:] = np.array(original_distribution_dt)
self.beam.dE[:] = np.array(original_distribution_dE)
self.long_tracker = RingAndRFTracker(
self.rf, self.beam, solver='simple')
for i in range(self.ring.n_turns):
self.long_tracker.track()
original_distribution_dt += self.ring.n_turns * linear_drift(
original_distribution_dE, self.ring.eta_0[0, 0],
self.ring.beta[0, 0], self.ring.energy[0, 0], self.ring.t_rev[0])
return self.beam.dt, original_distribution_dt, original_distribution_dE
def setUp(self):
# Bunch parameters
# -----------------
N_turn = 200
N_b = 1e9 # Intensity
N_p = int(2e6) # Macro-particles
# Machine parameters
# --------------------
C = 6911.5038 # Machine circumference [m]
p = 450e9 # Synchronous momentum [eV/c]
gamma_t = 17.95142852 # Transition gamma
alpha = 1./gamma_t**2 # First order mom. comp. factor
# Define general parameters
# --------------------------
self.general_params = Ring(C, alpha, p, Proton(), N_turn)
# Define beam
# ------------
self.beam = Beam(self.general_params, N_p, N_b)
# Define RF section
# -----------------
self.rf_params = RFStation(self.general_params, [4620], [7e6], [0.])
def setUp(self):
# Ring and RF definitions
ring = Ring(2 * np.pi * 1100.009,
1 / 18**2,
25.92e9,
Particle=Proton())
rf = RFStation(ring, [4620], [4.5e6], [0.], n_rf=1)
self.T_s = 5 * rf.t_rf[0, 0]
def test_exact_order1and2_vs_expectation(self):
self.ring = Ring(self.C,
self.alpha_0,
self.Ek,
Proton(),
self.N_t,
synchronous_data_type='kinetic energy',
alpha_1=self.alpha_1,
alpha_2=self.alpha_2)
self.beam = Beam(self.ring, self.N_p, self.N_b)
self.rf = RFStation(self.ring, 1, 0, np.pi)
original_distribution_dt = np.zeros(self.beam.n_macroparticles)
original_distribution_dE = np.linspace(-0.1 * self.beam.energy,
0.1 * self.beam.energy,
self.beam.n_macroparticles)
self.beam.dt[:] = np.array(original_distribution_dt)
self.beam.dE[:] = np.array(original_distribution_dE)
self.long_tracker = RingAndRFTracker(self.rf,
self.beam,
solver='exact')
# Forcing usage of legacy
self.long_tracker.solver = 'exact'
self.long_tracker.solver = self.long_tracker.solver.encode(
encoding='utf_8')
for i in range(self.ring.n_turns):
self.long_tracker.track()
original_distribution_dt += self.ring.n_turns * expected_drift(
original_distribution_dE, self.ring.alpha_0[0, 0],
self.ring.alpha_1[0, 0], self.ring.alpha_2[0, 0],
self.ring.energy[0, 0], self.ring.t_rev[0],
self.ring.ring_circumference, self.ring.Particle.mass)
np.testing.assert_allclose(self.beam.dt,
original_distribution_dt,
rtol=relative_tolerance,
atol=absolute_tolerance)
def setUp(self):
initial_time = 0
final_time = 25E-3
periodicity_tracking = True
# Machine and RF parameters
radius = 25
gamma_transition = 4.4 # [1]
C = 2 * np.pi * radius # [m]
momentum_compaction = 1 / gamma_transition**2 # [1]
particle_type = 'proton'
self.ring = Ring(C, momentum_compaction, \
([0, 25E-3], [3.13E8, 3.5E8]), Proton())
self.rf_params = RFStation(self.ring, [1, 2], [0, 0], \
[np.pi, np.pi*0.95], 2)
def setUp(self):
self.ring = Ring(self.C, self.alpha,
np.linspace(self.p_i, self.p_f, self.N_t + 1),
Proton(), self.N_t)
self.beam = Beam(self.ring, self.N_p, self.N_b)
self.rf = RFStation(self.ring, [self.h],
self.V * np.linspace(1, 1.1, self.N_t + 1),
[self.dphi])
bigaussian(self.ring,
self.rf,
self.beam,
self.tau_0 / 4,
reinsertion=True,
seed=1)
self.profile = Profile(
self.beam,
CutOptions(n_slices=100, cut_left=0, cut_right=self.rf.t_rf[0, 0]),
FitOptions(fit_option='gaussian'))
self.long_tracker = RingAndRFTracker(self.rf,
self.beam,
Profile=self.profile)
def setUp(self):
# Bunch parameters (dummy)
N_b = 1e9 # Intensity
N_p = 50000 # Macro-particles
# Machine and RF parameters
C = 26658.883 # Machine circumference [m]
p_s = 450e9 # Synchronous momentum [eV/c]
h = 35640 # Harmonic number
V = 4e6 # RF voltage [V]
dphi = 0 # Phase modulation/offset
gamma_t = 53.8 # Transition gamma
alpha = 1 / gamma_t**2 # First order mom. comp. factor
# Initialise necessary classes
ring = Ring(C, alpha, p_s, Particle=Proton(), n_turns=1)
self.rf = RFStation(ring, [h], [V], [dphi])
beam = Beam(ring, N_p, N_b)
self.profile = Profile(beam)
# Test in open loop, on tune
self.RFFB = LHCRFFeedback(open_drive=True)
self.f_c = self.rf.omega_rf[0, 0] / (2 * np.pi)
def setUp(self):
C = 2 * np.pi * 1100.009 # Ring circumference [m]
gamma_t = 18.0 # Gamma at transition
alpha = 1 / gamma_t**2 # Momentum compaction factor
p_s = 25.92e9 # Synchronous momentum at injection [eV]
N_m = 1e5 # Number of macro-particles for tracking
N_b = 1.0e11 # Bunch intensity [ppb]
# Set up machine parameters
self.ring = Ring(C, alpha, p_s, Proton(), n_turns=1)
# RF-frequency at which to compute beam current
self.omega = 2 * np.pi * 200.222e6
# Create Gaussian beam
self.beam = Beam(self.ring, N_m, N_b)
self.profile = Profile(self.beam,
CutOptions=CutOptions(cut_left=-1.e-9,
n_slices=100,
cut_right=6.e-9))
def setUp(self):
n_turns = 200
intensity_pb = 1.2e6 # protons per bunch
n_macroparticles = int(1e6) # macropartilces per bunch
sigma = 0.05e-9 # sigma for gaussian bunch [s]
self.time_offset = 0.1e-9 # time by which to offset the bunch
# Ring parameters SPS
C = 6911.5038 # Machine circumference [m]
sync_momentum = 25.92e9 # SPS momentum at injection [eV/c]
gamma_transition = 17.95142852 # Q20 Transition gamma
momentum_compaction = 1./gamma_transition**2 # Momentum compaction array
self.ring = Ring(C, momentum_compaction, sync_momentum, Proton(),
n_turns=n_turns)
# RF parameters SPS
harmonic = 4620 # Harmonic numbers
voltage = 4.5e6 # [V]
phi_offsets = 0
self.rf_station = RFStation(self.ring, harmonic, voltage, phi_offsets)
t_rf = self.rf_station.t_rf[0, 0]
# Beam setup
self.beam = Beam(self.ring, n_macroparticles, intensity_pb)
bigaussian(self.ring, self.rf_station, self.beam, sigma, seed=1234,
reinsertion=True)
# displace beam to see effect of phase error and phase loop
self.beam.dt += self.time_offset
# Profile setup
self.profile = Profile(self.beam, CutOptions=CutOptions(cut_left=0,
cut_right=t_rf,
n_slices=1024))
def run_expected_drift(self):
self.ring = Ring(self.C, self.alpha_0, self.Ek, Proton(), self.N_t,
synchronous_data_type='kinetic energy',
alpha_1=self.alpha_1, alpha_2=self.alpha_2)
self.beam = Beam(self.ring, self.N_p, self.N_b)
self.rf = RFStation(self.ring, 1, 0, np.pi)
original_distribution_dt = np.zeros(self.beam.n_macroparticles)
original_distribution_dE = np.linspace(
-0.1*self.beam.energy,
0.1*self.beam.energy,
self.beam.n_macroparticles)
original_distribution_dt += self.ring.n_turns * expected_drift(
original_distribution_dE, self.ring.alpha_0[0, 0],
self.ring.alpha_1[0, 0], self.ring.alpha_2[0, 0],
self.ring.energy[0, 0], self.ring.t_rev[0],
self.ring.ring_circumference, self.ring.Particle.mass)
return original_distribution_dt, original_distribution_dE
def run_exact_order1and2(self):
self.ring = Ring(self.C, self.alpha_0, self.Ek, Proton(), self.N_t,
synchronous_data_type='kinetic energy',
alpha_1=self.alpha_1, alpha_2=self.alpha_2)
self.beam = Beam(self.ring, self.N_p, self.N_b)
self.rf = RFStation(self.ring, 1, 0, np.pi)
original_distribution_dt = np.zeros(self.beam.n_macroparticles)
original_distribution_dE = np.linspace(
-0.1*self.beam.energy,
0.1*self.beam.energy,
self.beam.n_macroparticles)
self.beam.dt[:] = np.array(original_distribution_dt)
self.beam.dE[:] = np.array(original_distribution_dE)
self.long_tracker = RingAndRFTracker(
self.rf, self.beam, solver='exact')
# Forcing usage of legacy
self.long_tracker.solver = 'exact'
self.long_tracker.solver = self.long_tracker.solver.encode(
encoding='utf_8')
for i in range(self.ring.n_turns):
self.long_tracker.track()
original_distribution_dt += self.ring.n_turns * exact_drift(
original_distribution_dE, self.ring.alpha_0[0, 0],
self.ring.alpha_1[0, 0], self.ring.alpha_2[0, 0],
self.ring.beta[0, 0], self.ring.energy[0, 0], self.ring.t_rev[0])
return self.beam.dt, original_distribution_dt, original_distribution_dE
# Derived parameters
E_0 = m_p * c**2 / e # [eV]
tot_beam_energy = E_0 + kin_beam_energy # [eV]
sync_momentum = np.sqrt(tot_beam_energy**2 - E_0**2) # [eV / c]
momentum_compaction = 1 / gamma_transition**2 # [1]
# Cavities parameters
n_rf_systems = 1
harmonic_numbers = 1
voltage_program = 8e3 #[V]
phi_offset = np.pi
# DEFINE RING------------------------------------------------------------------
general_params = Ring(C, momentum_compaction, sync_momentum, Proton(), n_turns)
RF_sct_par = RFStation(general_params, [harmonic_numbers], [voltage_program],
[phi_offset], n_rf_systems)
my_beam = Beam(general_params, n_macroparticles, n_particles)
ring_RF_section = RingAndRFTracker(RF_sct_par, my_beam)
# DEFINE BEAM------------------------------------------------------------------
bigaussian(general_params, RF_sct_par, my_beam, sigma_dt, seed=1)
# DEFINE SLICES----------------------------------------------------------------
slice_beam = Profile(
my_beam,
CutOptions(cut_left=-5.72984173562e-7,
def setUp(self):
self.proton = Proton()
gamma = tot_beam_energy / E_0
beta = np.sqrt(1.0-1.0/gamma**2.0)
momentum_compaction = 1 / gamma_transition**2
# Cavities parameters
n_rf_systems = 1
harmonic_numbers = 35640.0
voltage_program = 16e6
phi_offset = 0
# DEFINE RING------------------------------------------------------------------
general_params = Ring(C, momentum_compaction,
sync_momentum, Proton(), n_turns)
RF_sct_par = RFStation(general_params, [harmonic_numbers], [voltage_program],
[phi_offset], n_rf_systems)
beam = Beam(general_params, n_macroparticles, n_particles)
ring_RF_section = RingAndRFTracker(RF_sct_par, beam)
full_tracker = FullRingAndRF([ring_RF_section])
fs = RF_sct_par.omega_s0[0]/2/np.pi
bucket_length = 2.0 * np.pi / RF_sct_par.omega_rf[0,0]
# DEFINE SLICES ---------------------------------------------------------------
# Tracking details
N_t = 1 # Number of turns to track
# -----------------------------------------------------------------------------
PLOT_NO_BEAM = True
# Plot settings
plt.rc('axes', labelsize=12, labelweight='normal')
plt.rc('lines', linewidth=1.5, markersize=6)
plt.rc('font', family='sans-serif')
plt.rc('legend', fontsize=12)
# Logger for messages on console & in file
Logger(debug=True)
ring = Ring(C, alpha, p_s, Particle=Proton(), n_turns=1)
rf = RFStation(ring, [h], [3.1e6],
[dphi]) # SPS-equivalent for 0.57 eVs, 1.65 ns
bunch = Beam(ring, N_m, N_p)
bigaussian(ring, rf, bunch, sigma_dt=1.65e-9 / 4) #tau_0)
# Real RF voltage
rf = RFStation(ring, [h], [V], [dphi])
beam = Beam(ring, N_m * NB, N_p * NB)
buckets = rf.t_rf[0, 0] * 10
for i in range(12):
beam.dt[i * N_m:(i + 1) * N_m] = bunch.dt[0:N_m] + i * buckets
beam.dE[i * N_m:(i + 1) * N_m] = bunch.dE[0:N_m]
for i in range(12, 60):
beam.dt[i * N_m:(i + 1) *
def setUp(self):
"""
Slicing of the same Gaussian profile using four distinct settings to
test different features.
"""
np.random.seed(1984)
intensity_pb = 1.0e11
sigma = 0.2e-9 # Gauss sigma, [s]
n_macroparticles_pb = int(1e4)
n_bunches = 2
# --- Ring and RF ----------------------------------------------
intensity = n_bunches * intensity_pb # total intensity SPS
n_turns = 1
# Ring parameters SPS
circumference = 6911.5038 # Machine circumference [m]
sync_momentum = 25.92e9 # SPS momentum at injection [eV/c]
gamma_transition = 17.95142852 # Q20 Transition gamma
momentum_compaction = 1. / gamma_transition**2 # Momentum compaction array
ring = Ring(circumference,
momentum_compaction,
sync_momentum,
Proton(),
n_turns=n_turns)
# RF parameters SPS
harmonic_number = 4620 # harmonic number
voltage = 3.5e6 # [V]
phi_offsets = 0
self.rf_station = RFStation(ring,
harmonic_number,
voltage,
phi_offsets,
n_rf=1)
t_rf = self.rf_station.t_rf[0, 0]
bunch_spacing = 5 # RF buckets
n_macroparticles = n_bunches * n_macroparticles_pb
self.beam = Beam(ring, n_macroparticles, intensity)
for bunch in range(n_bunches):
bunchBeam = Beam(ring, n_macroparticles_pb, intensity_pb)
bigaussian(ring,
self.rf_station,
bunchBeam,
sigma,
reinsertion=True,
seed=1984 + bunch)
self.beam.dt[bunch*n_macroparticles_pb : (bunch+1)*n_macroparticles_pb] \
= bunchBeam.dt + bunch*bunch_spacing * t_rf
self.beam.dE[bunch * n_macroparticles_pb:(bunch + 1) *
n_macroparticles_pb] = bunchBeam.dE
self.filling_pattern = np.zeros(bunch_spacing * (n_bunches - 1) + 1)
self.filling_pattern[::bunch_spacing] = 1
# uniform profile
profile_margin = 0 * t_rf
t_batch_begin = 0 * t_rf
t_batch_end = (bunch_spacing * (n_bunches - 1) + 1) * t_rf
self.n_slices_rf = 32 # number of slices per RF-bucket
cut_left = t_batch_begin - profile_margin
cut_right = t_batch_end + profile_margin
# number of rf-buckets of the self.beam
# + rf-buckets before the self.beam + rf-buckets after the self.beam
n_slices = self.n_slices_rf * (
bunch_spacing * (n_bunches - 1) + 1 +
int(np.round((t_batch_begin - cut_left) / t_rf)) +
int(np.round((cut_right - t_batch_end) / t_rf)))
self.uniform_profile = Profile(self.beam,
CutOptions=CutOptions(
cut_left=cut_left,
n_slices=n_slices,
cut_right=cut_right))
self.uniform_profile.track()
tau_0 = 1.0e-9 # Initial bunch length, 4 sigma [s]
# Machine and RF parameters
C = 26658.883 # Machine circumference [m]
p = 450e9 # Synchronous momentum [eV/c]
h = 35640 # Harmonic number
V = 6e6 # RF voltage [V]
dphi = 0 # Phase modulation/offset
gamma_t = 55.759505 # Transition gamma
alpha = 1. / gamma_t / gamma_t # First order mom. comp. factor
# Tracking details
N_t = 2000 # Number of turns to track
# Simulation setup ------------------------------------------------------------
ring = Ring(C, alpha, p, Proton(), N_t)
rf = RFStation(ring, [h], [V], [dphi])
beam = Beam(ring, N_p, N_b)
bigaussian(ring, rf, beam, tau_0 / 4, reinsertion=True, seed=1)
profile = Profile(beam,
CutOptions=CutOptions(n_slices=100,
cut_left=0,
cut_right=2.5e-9))
profile.track()
# Calculate oscillation amplitude from coordinates
dtmax, bin_centres, histogram = oscillation_amplitude_from_coordinates(
ring, rf, beam.dt, beam.dE, Np_histogram=100)
# Normalise profiles
profile.n_macroparticles /= np.sum(profile.n_macroparticles)
# Ring parameters SPS
circumference = 6911.5038 # Machine circumference [m]
sync_momentum = 25.92e9 # SPS momentum at injection [eV/c]
if optics == 'Q20':
gamma_transition = 17.95142852 # Q20 Transition gamma
elif optics == 'Q22':
gamma_transition = 20.071 # Q22 Transition gamma
else:
raise RuntimeError('No gamma_transition specified')
momentum_compaction = 1. / gamma_transition**2 # Momentum compaction array
ring = Ring(circumference,
momentum_compaction,
sync_momentum,
Proton(),
n_turns=n_turns)
tRev = ring.t_rev[0]
# RF parameters SPS
n_rf_systems = 1 # Number of rf systems
if n_rf_systems == 2:
V2_ratio = 1.00e-01 # voltage 800 MHz [V]
harmonic_numbers = [4620, 18480] # Harmonic numbers
voltage = [V1, V1 * V2_ratio]
phi_offsets = [0, np.pi]
elif n_rf_systems == 1:
harmonic_numbers = 4620 # Harmonic numbers
voltage = V1
phi_offsets = 0
def test_vind(self):
# randomly chose omega_c from allowed range
np.random.seed(1980)
factor = np.random.uniform(0.9, 1.1)
# round results to this digits
digit_round = 8
# SPS parameters
C = 2 * np.pi * 1100.009 # Ring circumference [m]
gamma_t = 18.0 # Gamma at transition
alpha = 1 / gamma_t**2 # Momentum compaction factor
p_s = 25.92e9 # Synchronous momentum at injection [eV]
h = 4620 # 200 MHz system harmonic
V = 4.5e6 # 200 MHz RF voltage
phi = 0. # 200 MHz RF phase
# Beam and tracking parameters
N_m = 1e5 # Number of macro-particles for tracking
N_b = 1.0e11 # Bunch intensity [ppb]
N_t = 1 # Number of turns to track
ring = Ring(C, alpha, p_s, Proton(), n_turns=N_t)
rf = RFStation(ring, h, V, phi)
beam = Beam(ring, N_m, N_b)
bigaussian(ring, rf, beam, 3.2e-9 / 4, seed=1234, reinsertion=True)
n_shift = 5 # how many rf-buckets to shift beam
beam.dt += n_shift * rf.t_rf[0, 0]
profile = Profile(beam,
CutOptions=CutOptions(
cut_left=(n_shift - 1.5) * rf.t_rf[0, 0],
cut_right=(n_shift + 1.5) * rf.t_rf[0, 0],
n_slices=140))
profile.track()
l_cav = 16.082
v_g = 0.0946
tau = l_cav / (v_g * c) * (1 + v_g)
TWC_impedance_source = TravelingWaveCavity(l_cav**2 * 27.1e3 / 8,
200.222e6, 2 * np.pi * tau)
# Beam loading by convolution of beam and wake from cavity
inducedVoltageTWC = InducedVoltageTime(beam, profile,
[TWC_impedance_source])
induced_voltage = TotalInducedVoltage(beam, profile,
[inducedVoltageTWC])
induced_voltage.induced_voltage_sum()
V_ind_impSource = np.around(induced_voltage.induced_voltage,
digit_round)
# Beam loading via feed-back system
OTFB_4 = SPSOneTurnFeedback(rf, beam, profile, 4, n_cavities=1)
OTFB_4.counter = 0 # First turn
OTFB_4.omega_c = factor * OTFB_4.TWC.omega_r
# Compute impulse response
OTFB_4.TWC.impulse_response_beam(OTFB_4.omega_c, profile.bin_centers)
# Compute induced voltage in (I,Q) coordinates
OTFB_4.beam_induced_voltage(lpf=False)
# convert back to time
V_ind_OTFB \
= OTFB_4.V_fine_ind_beam.real \
* np.cos(OTFB_4.omega_c*profile.bin_centers) \
+ OTFB_4.V_fine_ind_beam.imag \
* np.sin(OTFB_4.omega_c*profile.bin_centers)
V_ind_OTFB = np.around(V_ind_OTFB, digit_round)
self.assertListEqual(
V_ind_impSource.tolist(),
V_ind_OTFB.tolist(),
msg="In TravelingWaveCavity test_vind: induced voltages differ")
os.mkdir(this_directory + '../output_files/EX_08_fig')
except:
pass
# Beam parameters
n_macroparticles = 100000
n_particles = 0
# Machine and RF parameters
radius = 25 # [m]
gamma_transition = 4.076750841
alpha = 1 / gamma_transition**2
C = 2*np.pi*radius # [m]
n_turns = 500
general_params = Ring(C, alpha, 310891054.809,
Proton(), n_turns)
# Cavities parameters
n_rf_systems = 1
harmonic_numbers_1 = 1
voltage_1 = 8000 # [V]
phi_offset_1 = np.pi # [rad]
rf_params = RFStation(general_params, [harmonic_numbers_1], [voltage_1],
[phi_offset_1], n_rf_systems)
my_beam = Beam(general_params, n_macroparticles, n_particles)
cut_options = CutOptions(cut_left= 0, cut_right=2*np.pi, n_slices=200,
RFSectionParameters=rf_params, cuts_unit = 'rad')
slices_ring = Profile(my_beam, cut_options)
worker.greet()
if worker.isMaster:
worker.print_version()
worker.initLog(bool(args['log']), args['logdir'])
worker.initTrace(bool(args['trace']), args['tracefile'])
worker.taskparallelism = withtp
mpiprint(args)
# Simulation setup ------------------------------------------------------------
mpiprint("Setting up the simulation...")
# Define general parameters
ring = Ring(C, alpha, np.linspace(p_i, p_f, n_turns + 1), Proton(), n_turns)
# Define beam and distribution
beam = Beam(ring, n_particles, N_b)
# Define RF station parameters and corresponding tracker
rf = RFStation(ring, [h], [V], [dphi])
bigaussian(ring, rf, beam, tau_0 / 4, reinsertion=True, seed=seed)
# Need slices for the Gaussian fit
# TODO add the gaussian fit
profile = Profile(beam, CutOptions(n_slices=n_slices))
# FitOptions(fit_option='gaussian'))
long_tracker = RingAndRFTracker(rf, beam)
def test_rf_parameters_calculate_phi_s(self):
self.assertEqual(calculate_phi_s(self.rf_params, Particle=Proton())[0], numpy.pi,
msg="Wrong phi_s for Proton")
self.assertEqual(calculate_phi_s(self.rf_params, Particle=Electron())[0], 0.0,
msg="Wrong phi_s for Electron")
# unpack=True)
ps = np.ascontiguousarray(ps)
ps = np.concatenate((ps, np.ones(436627)*6.5e12))
else:
ps = 450.e9*np.ones(n_turns+1)
mpiprint("Flat top momentum %.4e eV" % ps[-1])
if REAL_RAMP:
V = np.concatenate((np.linspace(6.e6, 12.e6, 13563374),
np.ones(436627)*12.e6))
else:
V = 6.e6*np.ones(n_turns+1)
mpiprint("Flat top voltage %.4e V" % V[-1])
mpiprint("Momentum and voltage loaded...")
# Define general parameters
ring = Ring(C, alpha, ps[0:n_turns+1], Proton(), n_turns=n_turns)
mpiprint("General parameters set...")
# Define RF parameters (noise to be added for CC case)
rf = RFStation(ring, [h], [V[0:n_turns+1]], [0.])
mpiprint("RF parameters set...")
# Generate RF phase noise
LHCnoise = FlatSpectrum(ring, rf, fmin_s0=0.8571, fmax_s0=1.001,
initial_amplitude=1.e-5,
predistortion='weightfunction')
LHCnoise.dphi = np.load(
os.path.join(inputDir, 'LHCNoise_fmin0.8571_fmax1.001_ampl1e-5_weightfct_6.5TeV.npz'))['arr_0']
LHCnoise.dphi = np.ascontiguousarray(LHCnoise.dphi[0:n_turns+1])
mpiprint("RF phase noise loaded...")
h = 35640 # Harmonic number
V = 6e6 # RF voltage [V]
dphi = 0 # Phase modulation/offset
gamma_t = 55.759505 # Transition gamma
alpha = 1. / gamma_t / gamma_t # First order mom. comp. factor
# Tracking details
N_t = 2000 # Number of turns to track
dt_plt = int(sys.argv[2]) # Time steps between plots
# Simulation setup ------------------------------------------------------------
print("Setting up the simulation...")
print("")
# Define general parameters
ring = Ring(C, alpha, np.linspace(p_i, p_f, N_t + 1), Proton(), N_t)
# Define beam and distribution
beam = Beam(ring, N_p, N_b)
# Define RF station parameters and corresponding tracker
rf = RFStation(ring, [h], [V], [dphi])
long_tracker = RingAndRFTracker(rf, beam)
bigaussian(ring, rf, beam, tau_0 / 4, reinsertion=True, seed=1)
# Need slices for the Gaussian fit
# profile = Profile(beam, CutOptions(n_slices=N_p//1000),
# FitOptions(fit_option='gaussian'))
# Define what to save in file
# Tracking details
N_t = 2000 # Number of turns to track
dt_plt = 200 # Time steps between plots
# Simulation setup ------------------------------------------------------------
print("Setting up the simulation...")
print("")
# Define general parameters containing data for both RF stations
general_params = Ring([0.3*C, 0.7*C], [[alpha], [alpha]],
[p_s*np.ones(N_t+1), p_s*np.ones(N_t+1)],
Proton(), N_t, n_sections = 2)
# Define RF station parameters and corresponding tracker
beam = Beam(general_params, N_p, N_b)
rf_params_1 = RFStation(general_params, [h], [V1], [dphi],
section_index=1)
long_tracker_1 = RingAndRFTracker(rf_params_1, beam)
rf_params_2 = RFStation(general_params, [h], [V2], [dphi],
section_index=2)
long_tracker_2 = RingAndRFTracker(rf_params_2, beam)
# Define full voltage over one turn and a corresponding "overall" set of
#parameters, which is used for the separatrix (in plotting and losses)
Vtot = total_voltage([rf_params_1, rf_params_2])
def setUp(self):
C = 2*np.pi*1100.009 # Ring circumference [m]
gamma_t = 18.0 # Gamma at transition
alpha = 1/gamma_t**2 # Momentum compaction factor
p_s = 25.92e9 # Synchronous momentum at injection [eV]
h = 4620 # 200 MHz system harmonic
phi = 0. # 200 MHz RF phase
# With this setting, amplitude in the two four-section, five-section
# cavities must converge, respectively, to
# 2.0 MV = 4.5 MV * 4/18 * 2
# 2.5 MV = 4.5 MV * 5/18 * 2
V = 4.5e6 # 200 MHz RF voltage
N_t = 1 # Number of turns to track
self.ring = Ring(C, alpha, p_s, Particle=Proton(), n_turns=N_t)
self.rf = RFStation(self.ring, h, V, phi)
N_m = 1e6 # Number of macro-particles for tracking
N_b = 72*1.0e11 # Bunch intensity [ppb]
# Gaussian beam profile
self.beam = Beam(self.ring, N_m, N_b)
sigma = 1.0e-9
bigaussian(self.ring, self.rf, self.beam, sigma, seed=1234,
reinsertion=False)
n_shift = 1550 # how many rf-buckets to shift beam
self.beam.dt += n_shift * self.rf.t_rf[0, 0]
self.profile = Profile(
self.beam, CutOptions=CutOptions(
cut_left=(n_shift-1.5)*self.rf.t_rf[0, 0],
cut_right=(n_shift+2.5)*self.rf.t_rf[0, 0],
n_slices=4*64))
self.profile.track()
# Cavities
l_cav = 43*0.374
v_g = 0.0946
tau = l_cav/(v_g*c)*(1 + v_g)
f_cav = 200.222e6
n_cav = 2 # factor 2 because of two four/five-sections cavities
short_cavity = TravelingWaveCavity(l_cav**2 * n_cav * 27.1e3 / 8,
f_cav, 2*np.pi*tau)
shortInducedVoltage = InducedVoltageTime(self.beam, self.profile,
[short_cavity])
l_cav = 54*0.374
tau = l_cav/(v_g*c)*(1 + v_g)
long_cavity = TravelingWaveCavity(l_cav**2 * n_cav * 27.1e3 / 8, f_cav,
2*np.pi*tau)
longInducedVoltage = InducedVoltageTime(self.beam, self.profile,
[long_cavity])
self.induced_voltage = TotalInducedVoltage(
self.beam, self.profile, [shortInducedVoltage, longInducedVoltage])
self.induced_voltage.induced_voltage_sum()
self.cavity_tracker = RingAndRFTracker(
self.rf, self.beam, Profile=self.profile, interpolation=True,
TotalInducedVoltage=self.induced_voltage)
self.OTFB = SPSCavityFeedback(
self.rf, self.beam, self.profile, G_llrf=5, G_tx=0.5, a_comb=15/16,
turns=50, Commissioning=CavityFeedbackCommissioning())
self.OTFB_tracker = RingAndRFTracker(self.rf, self.beam,
Profile=self.profile,
TotalInducedVoltage=None,
CavityFeedback=self.OTFB,
interpolation=True)
except:
pass
# Beam parameters
n_macroparticles = 100000
n_particles = 0
# Machine and RF parameters
radius = 25 # [m]
gamma_transition = 4.076750841
alpha = 1 / gamma_transition**2
C = 2 * np.pi * radius # [m]
n_turns = 2000
general_params = Ring(C, alpha, 310891054.809, Proton(), n_turns)
# Cavities parameters
n_rf_systems = 1
harmonic_numbers_1 = 1
voltage_1 = 8000 # [V]
phi_offset_1 = np.pi # [rad]
rf_params = RFStation(general_params, [harmonic_numbers_1], [voltage_1],
[phi_offset_1], n_rf_systems)
my_beam = Beam(general_params, n_macroparticles, n_particles)
cut_options = CutOptions(cut_left=0, cut_right=2.0 * 0.9e-6, n_slices=200)
slices_ring = Profile(my_beam, cut_options)
#Phase loop
h = 35640 # Harmonic number
V = 6e6 # RF voltage [eV]
dphi = 0 # Phase modulation/offset
gamma_t = 55.759505 # Transition gamma
alpha = 1. / gamma_t / gamma_t # First order mom. comp. factor
# Tracking details
N_t = 200 # Number of turns to track
dt_plt = 20 # Time steps between plots
# Simulation setup -------------------------------------------------------------
print("Setting up the simulation...")
print("")
# Define general parameters
general_params = Ring(C, alpha, p_s, Proton(), N_t)
# Define RF station parameters and corresponding tracker
rf_params = RFStation(general_params, [h], [V], [0])
# Pre-processing: RF phase noise -----------------------------------------------
RFnoise = FlatSpectrum(general_params,
rf_params,
delta_f=1.12455000e-02,
fmin_s0=0,
fmax_s0=1.1,
seed1=1234,
seed2=7564,
initial_amplitude=1.11100000e-07,
folder_plots=this_directory +
'../output_files/EX_03_fig')
momentumTime = loaded_program['momentumTime'] / 1e3 # s momentum = loaded_program['momentum'] * 1e9 # eV/c rfPerHamonicTime = loaded_program['rfPerHamonicTime'] / 1e3 # s rfPerHamonicDict = loaded_program['rfPerHamonicDict'] rfProgH21 = rfPerHamonicDict.item()['21'] * 1e3 rfProgH21[rfPerHamonicTime >= 2.710] = rfProgH21[rfPerHamonicTime >= 2.710][0] c_time_injection = 0.170 c_time_extraction = 2.850 c_time_start = 2.055 # s c_time_end = c_time_extraction # General parameters PS particle_type = Proton() circumference = 2 * np.pi * 100 # Machine circumference [m] gamma_transition = 6.1 # Transition gamma momentum_compaction = 1. / gamma_transition**2 # Momentum compaction array # RF parameters PS n_rf_systems = 1 # Number of rf systems second section harmonic_number = 21 # Harmonic number section phi_offset = 0 # Phase offset voltage_ratio = 0.15 harmonic_ratio = 4 # Beam parameters n_bunches = 21 n_particles = 1e6
