xtrack 0.76.1__tar.gz → 0.77.0__tar.gz

{xtrack-0.76.1 → xtrack-0.77.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: xtrack
-Version: 0.76.1
+Version: 0.77.0
 Summary: Tracking library for particle accelerators
 Home-page: https://xsuite.readthedocs.io/
 Download-URL: https://pypi.python.org/pypi/xtrack

xtrack-0.77.0/examples/transition_crossing/000_bucket_and_long_matching.py

@@ -0,0 +1,107 @@
+import xtrack as xt
+import xpart as xp
+from xpart.longitudinal.rf_bucket import RFBucket
+
+import numpy as np
+from scipy.constants import c as clight
+from scipy.constants import e as qe
+import matplotlib.pyplot as plt
+
+gamma0 = 5 # defines the energy of the beam
+gamma_transition = 4.
+momentum_compaction_factor = 1 / gamma_transition**2
+compensate_phase = True
+
+particle_ref = xt.Particles(gamma0=gamma0,
+                            mass0=xt.PROTON_MASS_EV)
+
+circumference = 1000.
+t_rev = circumference / (particle_ref.beta0[0] * clight)
+f_rev = 1 / t_rev
+
+energy_ref_increment =  50e3 # eV
+
+eta = momentum_compaction_factor - 1 / particle_ref.gamma0[0]**2
+
+h_rf = 40
+
+f_rf = h_rf * f_rev
+v_rf = 100e3
+lag_rf = 180. if eta > 0. else 0.
+
+# Compute momentum increment using auxiliary particle
+dp0c_eV = energy_ref_increment / particle_ref.beta0[0]
+
+if compensate_phase:
+    phi = np.arcsin(dp0c_eV * particle_ref.beta0[0] / v_rf)
+    if eta > 0:
+        phi = np.pi - phi
+    lag_rf = np.rad2deg(phi)
+
+otm = xt.LineSegmentMap(
+    betx=1., bety=1,
+    qx=6.3, qy=6.4,
+    momentum_compaction_factor=momentum_compaction_factor,
+    longitudinal_mode="nonlinear",
+    voltage_rf=v_rf,
+    frequency_rf=f_rf,
+    lag_rf=lag_rf,
+    length=circumference,
+    energy_ref_increment=energy_ref_increment
+)
+
+line = xt.Line(elements=[otm], particle_ref=particle_ref)
+
+tw = line.twiss()
+
+delta_test = np.linspace(0, 5e-3, 20)
+p = line.build_particles(delta=delta_test)
+
+line.track(p, turn_by_turn_monitor=True, num_turns=1000)
+mon = line.record_last_track
+
+p_gauss, matcher = xp.generate_matched_gaussian_bunch(
+    line=line,
+    num_particles=10_000,
+    nemitt_x=2.5e-6,
+    nemitt_y=2.5e-6,
+    sigma_z=2.,
+    return_matcher=True)
+
+rfb = line._get_bucket()
+z_separatrix = np.linspace(rfb.z_left, rfb.z_right, 1000)
+delta_separatrix = rfb.separatrix(z_separatrix)
+
+plt.close('all')
+plt.figure(1)
+plt.plot(p_gauss.zeta, p_gauss.delta, '.', color='k', alpha=0.5)
+plt.plot(mon.zeta.T, mon.delta.T, color='C0')
+plt.plot(z_separatrix, delta_separatrix, color='C1')
+plt.plot(z_separatrix, -delta_separatrix, color='C1')
+plt.xlabel('zeta [m]')
+plt.ylabel('delta')
+
+# Check the force and hamiltonian
+z_test = np.linspace(-30, 30, 1000)
+force = rfb.total_force(z_test)
+hamiltonian = rfb.hamiltonian(z_test, 0)
+
+plt.figure(2)
+ax1 = plt.subplot(2,1,1)
+ax1.plot(z_test, force)
+ax1.set_ylabel(r'F($\zeta$)')
+ax2 = plt.subplot(2,1,2, sharex=ax1)
+ax2.plot(z_test, hamiltonian)
+ax2.set_xlabel(r'$\zeta$ [m]')
+ax2.set_ylabel(r'$H(\zeta, 0)$')
+
+# Check hamiltonian on the delta axis
+delta_test = np.linspace(-1e-2, 1e-2, 1000)
+plt.figure(3)
+plt.plot(delta_test, matcher.rfbucket.hamiltonian(0, delta_test))
+plt.plot(delta_test, matcher.psi_object.H(0, delta_test))
+plt.plot(delta_test, matcher.rfbucket.hamiltonian(0, delta_test, make_convex=True), '--')
+plt.xlabel(r'$\delta$')
+plt.ylabel(r'$H(0, \delta)$')
+
+plt.show()

xtrack-0.77.0/examples/transition_crossing/001_check_energy_variables.py

@@ -0,0 +1,57 @@
+import xtrack as xt
+import xobjects as xo
+import numpy as np
+from scipy.constants import c as clight
+
+p = xt.Particles(mass0=xt.PROTON_MASS_EV, q0=1,
+                 kinetic_energy0=50e6, delta=0.1)
+
+beta0 = p.beta0[0]
+gamma0 = p.gamma0[0]
+mass0_ev = p.mass0
+energy0 = p.energy0[0]
+energy = p.energy[0]
+p0c = p.p0c[0]
+
+delta = p.delta[0]
+ptau = p.ptau[0]
+pzeta = p.pzeta[0]
+
+beta = beta0 * p.rvv[0]
+gamma = energy / energy0 * gamma0
+
+xo.assert_allclose(gamma0, 1 / np.sqrt(1 - beta0**2), rtol=0, atol=1e-14)
+xo.assert_allclose(gamma, 1 / np.sqrt(1 - beta**2), rtol=0, atol=1e-14)
+xo.assert_allclose(energy, mass0_ev * gamma, rtol=0, atol=1e-6) # 1e-6 eV
+xo.assert_allclose(energy0, mass0_ev * gamma0, rtol=0, atol=1e-6) # 1e-6 eV
+
+Pc = p0c * (1 + delta)
+xo.assert_allclose(Pc, mass0_ev * gamma * beta, rtol=0, atol=1e-6) # 1e-6 eV
+
+# Definitions delta/ptau/pzeta
+xo.assert_allclose(delta, (Pc - p0c) / p0c, rtol=0, atol=1e-14)
+xo.assert_allclose(ptau, (energy - energy0) / energy0 / beta0, rtol=0, atol=1e-14)
+xo.assert_allclose(pzeta,(energy - energy0) / energy0 / beta0**2, rtol=0, atol=1e-14)
+xo.assert_allclose(pzeta,(energy - energy0) / p0c / beta0, rtol=0, atol=1e-14)
+
+# Conversions
+xo.assert_allclose(delta, np.sqrt(ptau**2 + 2*ptau/beta0 + 1) - 1, rtol=0, atol=1e-14)
+xo.assert_allclose(delta, np.sqrt(beta0**2 * pzeta**2 + 2*pzeta + 1) - 1, rtol=0, atol=1e-14)
+xo.assert_allclose(delta, beta * ptau + (beta - beta0)/beta0, rtol=0, atol=1e-14)
+xo.assert_allclose(delta, beta * beta0 * pzeta + (beta - beta0)/beta0, rtol=0, atol=1e-14)
+
+# More relations from the physics manual
+xo.assert_allclose(gamma, gamma0 * (1 + beta0 * ptau), rtol=0, atol=1e-14)
+xo.assert_allclose(beta, np.sqrt(1 - (1 - beta0**2)/(1 + beta0 * ptau)**2), rtol=0, atol=1e-14)
+
+# Check relations for small energy deviations
+p_small = xt.Particles(mass0=xt.PROTON_MASS_EV, q0=1,
+                       kinetic_energy0=50e6, delta=1e-4)
+delta_small = p_small.delta[0]
+ptau_small = p_small.ptau[0]
+pzeta_small = p_small.pzeta[0]
+beta_small = beta0 * p_small.rvv[0]
+
+xo.assert_allclose(delta_small, ptau_small/beta0, rtol=0, atol=1e-8)
+xo.assert_allclose(delta_small, pzeta_small, rtol=0, atol=1e-8)
+xo.assert_allclose(beta_small, beta0 + (1 - beta0**2) * ptau_small, rtol=0, atol=1e-8)

xtrack-0.77.0/examples/transition_crossing/002_transition_crossing.py

@@ -0,0 +1,178 @@
+import xtrack as xt
+import xpart as xp
+from xpart.longitudinal.rf_bucket import RFBucket
+
+import numpy as np
+from scipy.constants import c as clight
+from scipy.constants import e as qe
+from scipy.interpolate import interp1d
+import matplotlib.pyplot as plt
+
+gamma0 = 3. # defines the energy of the beam
+gamma_transition = 4.
+momentum_compaction_factor = 1 / gamma_transition**2
+compensate_phase = True
+
+particle_ref = xt.Particles(gamma0=gamma0,
+                            mass0=xt.PROTON_MASS_EV)
+
+circumference = 1000.
+t_rev = circumference / (particle_ref.beta0[0] * clight)
+f_rev = 1 / t_rev
+
+energy_ref_increment =  50e3
+
+eta = momentum_compaction_factor - 1 / particle_ref.gamma0[0]**2
+
+h_rf = 40
+
+f_rf = h_rf * f_rev
+v_rf = 100e3
+lag_rf = 180. if eta > 0. else 0.
+
+# Compute momentum increment using auxiliary particle
+dp0c_eV = energy_ref_increment / particle_ref.beta0[0]
+
+if compensate_phase:
+    phi_below = np.arcsin(dp0c_eV * particle_ref.beta0[0] / v_rf)
+    phi_above = np.pi - phi_below
+    lag_rf_above = np.rad2deg(phi_above)
+    lag_rf_below = np.rad2deg(phi_below)
+    if eta > 0:
+        lag_rf = lag_rf_above
+    else:
+        lag_rf = lag_rf_below
+
+otm = xt.LineSegmentMap(
+    betx=1., bety=1,
+    qx=6.3, qy=6.4,
+    momentum_compaction_factor=momentum_compaction_factor,
+    longitudinal_mode="nonlinear",
+    voltage_rf=v_rf,
+    frequency_rf=f_rf,
+    lag_rf=lag_rf,
+    length=circumference,
+    energy_ref_increment=energy_ref_increment
+)
+
+line = xt.Line(elements={'otm': otm}, particle_ref=particle_ref)
+
+tw = line.twiss()
+
+p, matcher = xp.generate_matched_gaussian_bunch(
+    line=line,
+    num_particles=10_000,
+    nemitt_x=2.5e-6,
+    nemitt_y=2.5e-6,
+    sigma_z=5,
+    return_matcher=True)
+
+
+# Logger (log every ten turns)
+num_turns = 50_000
+log_every = 20
+n_log = num_turns // log_every
+mon = xt.ParticlesMonitor(
+    start_at_turn=0,
+    stop_at_turn=1,
+    n_repetitions=n_log,
+    repetition_period=log_every,
+    num_particles=len(p.x))
+
+#########
+# Track #
+#########
+
+jumped = False
+i_jumped = None
+while p.at_turn[0] < num_turns:
+    print(f'Turn {p.at_turn[0]}/{num_turns}            ', end='\r', flush=True)
+
+    # Phase jump
+    if p.gamma0[0] > gamma_transition and not jumped:
+        print(f'Jumped at turn: {p.at_turn[0]}')
+        line['otm'].lag_rf = lag_rf_above
+        i_jumped = p.at_turn[0]
+        jumped = True
+
+    # Track
+    line.track(p, num_turns=100, turn_by_turn_monitor=mon)
+    p.reorganize() # (put lost particles at the end)
+
+############
+# Plotting #
+############
+
+# Generate separatrix for video
+i_separatrix = []
+z_separatrix = []
+delta_separatrix = []
+for i_sep in np.arange(0, num_turns, 100):
+    print(f'Separatrix {i_sep}/{num_turns}            ', end='\r', flush=True)
+    line.particle_ref.gamma0 = mon.gamma0[i_sep//log_every, 0, 0]
+    line['otm'].lag_rf = lag_rf_above if i_sep >= i_jumped else lag_rf_below
+    try:
+        rfb = line._get_bucket()
+        i_separatrix.append(i_sep)
+        z_separatrix.append(np.linspace(rfb.z_left, rfb.z_right, 1000))
+        delta_separatrix.append(rfb.separatrix(z_separatrix[-1]))
+    except:
+        i_separatrix.append(i_sep)
+        z_separatrix.append(np.zeros(1000))
+        delta_separatrix.append(np.zeros(1000))
+        z_separatrix[-1][:] = -1e20
+        delta_separatrix[-1][:] = 0
+
+sigma_z_rms = np.squeeze(mon.zeta.std(axis=1))
+z_separatrix = np.array(z_separatrix)
+delta_separatrix = np.array(delta_separatrix)
+i_separatrix = np.array(i_separatrix)
+
+plt.close('all')
+fig1 = plt.figure(1)
+plt.plot(mon.at_turn[:, 0, 0], sigma_z_rms)
+plt.xlabel('Turn')
+plt.ylabel('Bunch length [m]')
+plt.show()
+
+f_sep_z = interp1d(i_separatrix, z_separatrix, axis=0,
+                   bounds_error=False, fill_value='extrapolate')
+f_sep_delta = interp1d(i_separatrix, delta_separatrix, axis=0,
+                       bounds_error=False, fill_value='extrapolate')
+
+# Make movie (needed `conda install -c conda-forge ffmpeg``)
+def update_plot(i_log, fig):
+    i_turn = mon.at_turn[i_log, 0, 0]
+    z_sep = f_sep_z(i_turn)
+    delta_sep = f_sep_delta(i_turn)
+
+    plot_separatrix = True
+    if np.abs(i_turn - i_jumped) < 100:
+        plot_separatrix = False
+
+    phi_rf_deg = np.rad2deg(phi_above) if i_turn >= i_jumped else np.rad2deg(phi_below)
+    plt.clf()
+    plt.plot(mon.zeta[i_log, :], mon.delta[i_log, :], '.', markersize=1)
+    if plot_separatrix:
+        plt.plot(z_sep, delta_sep, color='C1', linewidth=2)
+        plt.plot(z_sep, -delta_sep, color='C1', linewidth=2)
+    plt.xlim(-10, 10)
+    plt.ylim(-10e-3, 10e-3)
+    plt.xlabel('z [m]')
+    plt.ylabel(r'$\Delta p / p_0$')
+    plt.title(f'Turn {i_turn} '
+              r'$\sigma_\zeta = $' f'{sigma_z_rms[i_log]:.2f}\n'
+              r'$\gamma_0 = $' f'{mon.gamma0[i_log, 0, 0]:.2f} '
+              r'$\gamma_t = $' f'{gamma_transition:.2f} '
+              r'$\phi_{\mathrm{rf}} = $' f'{phi_rf_deg:.2f}')
+    plt.subplots_adjust(left=0.2, top=0.82)
+    plt.grid(alpha=0.5)
+
+fig = plt.figure()
+from matplotlib.animation import FFMpegFileWriter
+moviewriter = FFMpegFileWriter(fps=15)
+with moviewriter.saving(fig, 'transition.mp4', dpi=100):
+    for j in range(0, len(mon.zeta[:, 0, 0]), 1):
+        print(f'Frame {j}/{len(mon.zeta[:, 0, 0])}            ', end='\r', flush=True)
+        update_plot(j, fig)
+        moviewriter.grab_frame()

xtrack-0.77.0/examples/transition_crossing/t000_bucket_checks_below_transition.py

@@ -0,0 +1,172 @@
+import xtrack as xt
+import xpart as xp
+import xobjects as xo
+from xpart.longitudinal.rf_bucket import RFBucket
+
+import numpy as np
+from scipy.constants import c as clight
+from scipy.constants import e as qe
+import matplotlib.pyplot as plt
+
+gamma0 = 3 # defines the energy of the beam
+gamma_transition = 4.
+momentum_compaction_factor = 1 / gamma_transition**2
+
+particle_ref = xt.Particles(gamma0=gamma0,
+                            mass0=xt.PROTON_MASS_EV)
+
+circumference = 1000.
+t_rev = circumference / (particle_ref.beta0[0] * clight)
+f_rev = 1 / t_rev
+
+energy_ref_increment =  50e3 # eV
+
+eta = momentum_compaction_factor - 1 / particle_ref.gamma0[0]**2
+assert eta < 0
+
+h_rf = 40
+
+f_rf = h_rf * f_rev
+v_rf = 100e3
+lag_rf = 180. if eta > 0. else 0.
+
+# Compute momentum increment using auxiliary particle
+dp0c_eV = energy_ref_increment / particle_ref.beta0[0]
+
+phi = np.arcsin(dp0c_eV * particle_ref.beta0[0] / v_rf)
+if eta > 0:
+    phi = np.pi - phi
+lag_rf = np.rad2deg(phi)
+
+otm = xt.LineSegmentMap(
+    betx=1., bety=1,
+    qx=6.3, qy=6.4,
+    momentum_compaction_factor=momentum_compaction_factor,
+    longitudinal_mode="nonlinear",
+    voltage_rf=v_rf,
+    frequency_rf=f_rf,
+    lag_rf=lag_rf,
+    length=circumference,
+    energy_ref_increment=energy_ref_increment
+)
+
+line = xt.Line(elements={'otm': otm}, particle_ref=particle_ref)
+
+tw = line.twiss()
+xo.assert_allclose(tw.slip_factor, eta, atol=1e-3, rtol=0)
+xo.assert_allclose(tw.qs, 0.0032729, atol=1e-7, rtol=0)
+
+rfb = line._get_bucket()
+
+# Mostly checking that they do not change
+xo.assert_allclose(line['otm'].lag_rf[0], 30., # degrees
+                   atol=1e-4, rtol=0)
+
+xo.assert_allclose(np.rad2deg(rfb.dphi[0]), 30.,
+                   atol=1e-4, rtol=0)
+
+xo.assert_allclose(rfb.z_sfp, 0, atol=1e-4, rtol=0)
+xo.assert_allclose(rfb.z_ufp, -8.33333, atol=1e-4, rtol=0)
+xo.assert_allclose(rfb.z_left, rfb.z_ufp, atol=1e-4, rtol=0)
+xo.assert_allclose(rfb.z_right, 4.7699056, atol=1e-4, rtol=0)
+
+xo.assert_allclose(rfb.h_sfp(), -30.78255, atol=1e-3, rtol=0)
+xo.assert_allclose(rfb.h_sfp(), rfb.hamiltonian(0, 0), atol=1e-3, rtol=0)
+xo.assert_allclose(rfb.h_sfp(make_convex=True), 30.78255, atol=1e-3, rtol=0)
+xo.assert_allclose(rfb.h_sfp(make_convex=True),
+                   rfb.hamiltonian(rfb.z_sfp, 0, make_convex=True),
+                   atol=1e-3, rtol=0)
+
+# Build separatrix
+z_separatrix_up = np.linspace(rfb.z_left, rfb.z_right, 1000)
+delta_separatrix_up = rfb.separatrix(z_separatrix_up)
+
+z_separatrix = np.array(
+    list(z_separatrix_up) + list(z_separatrix_up[::-1]))
+delta_separatrix = np.array(
+    list(delta_separatrix_up) + list(-delta_separatrix_up[::-1]))
+
+# Hamiltonian is defined to be zero on the separatrix
+xo.assert_allclose(rfb.hamiltonian(z_separatrix, delta_separatrix), 0,
+                   atol=1e-3, rtol=0)
+xo.assert_allclose(rfb.hamiltonian(z_separatrix, delta_separatrix, make_convex=True), 0,
+                   atol=1e-3, rtol=0)
+
+# Check that the separatrix behaves as such in tracking
+p = line.build_particles(delta=delta_separatrix[::10]*0.99, zeta=z_separatrix[::10]*0.99)
+line.track(p, turn_by_turn_monitor=True, num_turns=3000)
+mon = line.record_last_track
+assert np.all(mon.zeta < rfb.z_right)
+assert np.all(mon.zeta > rfb.z_left)
+
+p = line.build_particles(delta=delta_separatrix[::10]*1.01, zeta=z_separatrix[::10]*1.01)
+line.track(p, turn_by_turn_monitor=True, num_turns=3000)
+mon = line.record_last_track
+assert not np.all(mon.zeta < rfb.z_right)
+assert not np.all(mon.zeta > rfb.z_left)
+
+# Check the stable fixed point against tracking
+p = line.build_particles(delta=0, zeta=rfb.z_sfp)
+line.track(p, turn_by_turn_monitor=True, num_turns=3000)
+mon = line.record_last_track
+xo.assert_allclose(mon.zeta, rfb.z_sfp, atol=2e-3*(rfb.z_right - rfb.z_left),
+                   rtol=0)
+bucket_height = rfb.separatrix(rfb.z_sfp)[0]
+xo.assert_allclose(mon.delta, 0, atol=2e-2*bucket_height, rtol=0)
+
+# Fix numpy random seed
+np.random.seed(0)
+
+# Match a bunch
+sigma_z = 2.
+p, matcher = xp.generate_matched_gaussian_bunch(
+    line=line,
+    num_particles=100_000,
+    nemitt_x=2.5e-6,
+    nemitt_y=2.5e-6,
+    sigma_z=sigma_z,
+    return_matcher=True)
+sigma_delta = p.delta.std()
+
+assert np.all(p.zeta < rfb.z_right)
+assert np.all(p.zeta > rfb.z_left)
+assert np.all(p.delta < bucket_height)
+assert np.all(p.delta > -bucket_height)
+
+xo.assert_allclose(p.delta.max(), bucket_height, atol=0, rtol=0.03)
+xo.assert_allclose(p.delta.min(), -bucket_height, atol=0, rtol=0.03)
+xo.assert_allclose(p.zeta.max(), rfb.z_right, atol=0, rtol=0.03)
+xo.assert_allclose(p.zeta.min(), rfb.z_left, atol=0, rtol=0.05) # this part of the bucket is poorly populated
+xo.assert_allclose(p.zeta.std(), sigma_z, atol=0, rtol=0.001)
+
+# Check that the distribution stays roughly stable over one synchrotron period
+p, matcher = xp.generate_matched_gaussian_bunch(
+    line=line,
+    num_particles=10_000,
+    nemitt_x=2.5e-6,
+    nemitt_y=2.5e-6,
+    sigma_z=sigma_z,
+    return_matcher=True)
+
+num_turns = int(np.round(1/tw.qs))
+log_every = 3
+n_log = num_turns // log_every
+mon = xt.ParticlesMonitor(
+    start_at_turn=0,
+    stop_at_turn=1,
+    n_repetitions=n_log,
+    repetition_period=log_every,
+    num_particles=len(p.x))
+
+line.track(p, num_turns=num_turns, turn_by_turn_monitor=mon,
+           with_progress=10)
+
+z_mean = np.squeeze(np.mean(mon.zeta, axis=1))
+z_std = np.squeeze(np.std(mon.zeta, axis=1))
+delta_mean = np.squeeze(np.mean(mon.delta, axis=1))
+delta_std = np.squeeze(np.std(mon.delta, axis=1))
+
+xo.assert_allclose(z_mean, np.mean(z_mean), atol=0.02*sigma_z)
+xo.assert_allclose(z_std, np.mean(z_std), atol=0.02*sigma_z)
+xo.assert_allclose(delta_mean, np.mean(delta_mean), atol=0.02*sigma_delta)
+xo.assert_allclose(delta_std, np.mean(delta_std), atol=0.02*sigma_delta)

xtrack-0.77.0/examples/transition_crossing/t001_bucket_checks_above_transition.py

@@ -0,0 +1,171 @@
+import xtrack as xt
+import xpart as xp
+import xobjects as xo
+from xpart.longitudinal.rf_bucket import RFBucket
+
+import numpy as np
+from scipy.constants import c as clight
+from scipy.constants import e as qe
+import matplotlib.pyplot as plt
+
+gamma0 = 10. # defines the energy of the beam
+gamma_transition = 4.
+momentum_compaction_factor = 1 / gamma_transition**2
+
+particle_ref = xt.Particles(gamma0=gamma0,
+                            mass0=xt.PROTON_MASS_EV)
+
+circumference = 1000.
+t_rev = circumference / (particle_ref.beta0[0] * clight)
+f_rev = 1 / t_rev
+
+energy_ref_increment =  50e3 # eV
+
+eta = momentum_compaction_factor - 1 / particle_ref.gamma0[0]**2
+assert eta > 0
+
+h_rf = 40
+
+f_rf = h_rf * f_rev
+v_rf = 100e3
+lag_rf = 180. if eta > 0. else 0.
+
+# Compute momentum increment using auxiliary particle
+dp0c_eV = energy_ref_increment / particle_ref.beta0[0]
+phi = np.arcsin(dp0c_eV * particle_ref.beta0[0] / v_rf)
+if eta > 0:
+    phi = np.pi - phi
+lag_rf = np.rad2deg(phi)
+
+otm = xt.LineSegmentMap(
+    betx=1., bety=1,
+    qx=6.3, qy=6.4,
+    momentum_compaction_factor=momentum_compaction_factor,
+    longitudinal_mode="nonlinear",
+    voltage_rf=v_rf,
+    frequency_rf=f_rf,
+    lag_rf=lag_rf,
+    length=circumference,
+    energy_ref_increment=energy_ref_increment
+)
+
+line = xt.Line(elements={'otm': otm}, particle_ref=particle_ref)
+
+tw = line.twiss()
+xo.assert_allclose(tw.slip_factor, eta, atol=1e-3, rtol=0)
+xo.assert_allclose(tw.qs, 0.00176525, atol=1e-7, rtol=0)
+
+rfb = line._get_bucket()
+
+# Mostly checking that they do not change
+xo.assert_allclose(line['otm'].lag_rf[0], 180-30., # degrees
+                   atol=1e-4, rtol=0)
+
+xo.assert_allclose(np.rad2deg(rfb.dphi[0]), 180-30.,
+                   atol=1e-4, rtol=0)
+
+xo.assert_allclose(rfb.z_sfp, 0, atol=1e-4, rtol=0)
+xo.assert_allclose(rfb.z_ufp, 8.33333, atol=1e-4, rtol=0)
+xo.assert_allclose(rfb.z_left, -4.76990, atol=1e-4, rtol=0)
+xo.assert_allclose(rfb.z_right, rfb.z_ufp, atol=1e-4, rtol=0)
+
+xo.assert_allclose(rfb.h_sfp(), 8.75048, atol=1e-3, rtol=0)
+xo.assert_allclose(rfb.h_sfp(), rfb.hamiltonian(0, 0), atol=1e-3, rtol=0)
+xo.assert_allclose(rfb.h_sfp(make_convex=True), 8.75048, atol=1e-3, rtol=0)
+xo.assert_allclose(rfb.h_sfp(make_convex=True),
+                   rfb.hamiltonian(rfb.z_sfp, 0, make_convex=True),
+                   atol=1e-3, rtol=0)
+
+# Build separatrix
+z_separatrix_up = np.linspace(rfb.z_left, rfb.z_right, 1000)
+delta_separatrix_up = rfb.separatrix(z_separatrix_up)
+
+z_separatrix = np.array(
+    list(z_separatrix_up) + list(z_separatrix_up[::-1]))
+delta_separatrix = np.array(
+    list(delta_separatrix_up) + list(-delta_separatrix_up[::-1]))
+
+# Hamiltonian is defined to be zero on the separatrix
+xo.assert_allclose(rfb.hamiltonian(z_separatrix, delta_separatrix), 0,
+                   atol=1e-3, rtol=0)
+xo.assert_allclose(rfb.hamiltonian(z_separatrix, delta_separatrix, make_convex=True), 0,
+                   atol=1e-3, rtol=0)
+
+# Check that the separatrix behaves as such in tracking
+p = line.build_particles(delta=delta_separatrix[::10]*0.98, zeta=z_separatrix[::10]*0.98)
+line.track(p, turn_by_turn_monitor=True, num_turns=3000)
+mon = line.record_last_track
+assert np.all(mon.zeta < rfb.z_right)
+assert np.all(mon.zeta > rfb.z_left)
+
+p = line.build_particles(delta=delta_separatrix[::10]*1.01, zeta=z_separatrix[::10]*1.01)
+line.track(p, turn_by_turn_monitor=True, num_turns=3000)
+mon = line.record_last_track
+assert not np.all(mon.zeta < rfb.z_right)
+assert not np.all(mon.zeta > rfb.z_left)
+
+# Check the stable fixed point against tracking
+p = line.build_particles(delta=0, zeta=rfb.z_sfp)
+line.track(p, turn_by_turn_monitor=True, num_turns=3000)
+mon = line.record_last_track
+xo.assert_allclose(mon.zeta, rfb.z_sfp, atol=2e-3*(rfb.z_right - rfb.z_left),
+                   rtol=0)
+bucket_height = rfb.separatrix(rfb.z_sfp)[0]
+xo.assert_allclose(mon.delta, 0, atol=2e-2*bucket_height, rtol=0)
+
+# Fix numpy random seed
+np.random.seed(0)
+
+# Match a bunch
+sigma_z = 2.
+p, matcher = xp.generate_matched_gaussian_bunch(
+    line=line,
+    num_particles=100_000,
+    nemitt_x=2.5e-6,
+    nemitt_y=2.5e-6,
+    sigma_z=sigma_z,
+    return_matcher=True)
+sigma_delta = p.delta.std()
+
+assert np.all(p.zeta < rfb.z_right)
+assert np.all(p.zeta > rfb.z_left)
+assert np.all(p.delta < bucket_height)
+assert np.all(p.delta > -bucket_height)
+
+xo.assert_allclose(p.delta.max(), bucket_height, atol=0, rtol=0.03)
+xo.assert_allclose(p.delta.min(), -bucket_height, atol=0, rtol=0.03)
+xo.assert_allclose(p.zeta.max(), rfb.z_right, atol=0, rtol=0.7) # this part of the bucket is poorly populated
+xo.assert_allclose(p.zeta.min(), rfb.z_left, atol=0, rtol=0.03)
+xo.assert_allclose(p.zeta.std(), sigma_z, atol=0, rtol=0.002)
+
+# Check that the distribution stays roughly stable over one synchrotron period
+p, matcher = xp.generate_matched_gaussian_bunch(
+    line=line,
+    num_particles=10_000,
+    nemitt_x=2.5e-6,
+    nemitt_y=2.5e-6,
+    sigma_z=sigma_z,
+    return_matcher=True)
+
+num_turns = int(np.round(1/tw.qs))
+log_every = 3
+n_log = num_turns // log_every
+mon = xt.ParticlesMonitor(
+    start_at_turn=0,
+    stop_at_turn=1,
+    n_repetitions=n_log,
+    repetition_period=log_every,
+    num_particles=len(p.x))
+
+line.track(p, num_turns=num_turns, turn_by_turn_monitor=mon,
+           with_progress=10)
+
+z_mean = np.squeeze(np.mean(mon.zeta, axis=1))
+z_std = np.squeeze(np.std(mon.zeta, axis=1))
+delta_mean = np.squeeze(np.mean(mon.delta, axis=1))
+delta_std = np.squeeze(np.std(mon.delta, axis=1))
+
+xo.assert_allclose(z_mean, np.mean(z_mean), atol=0.02*sigma_z)
+xo.assert_allclose(z_std, np.mean(z_std), atol=0.02*sigma_z)
+xo.assert_allclose(delta_mean, np.mean(delta_mean), atol=0.02*sigma_delta)
+xo.assert_allclose(delta_std, np.mean(delta_std), atol=0.02*sigma_delta)