xcoll 0.4.0__py3-none-any.whl → 0.5.1__py3-none-any.whl

xcoll/scattering_routines/geant4/collimasim/tests/test_xtrack_angle.py

@@ -0,0 +1,74 @@
+import numpy as np
+import xobjects as xo
+import xtrack as xt
+import xpart as xp
+
+import collimasim as cs
+from matplotlib import pyplot as plt
+
+import multiprocessing
+
+def make_particles():
+    np.random.seed(seed=1994)
+    n_part = 100
+    particles = xp.Particles(
+        _capacity=n_part,
+		p0c = 1.e3, # 1 KeV dummy particles
+        mass0 = xp.ELECTRON_MASS_EV,
+        x=np.linspace(0.15, 0.25, n_part), # Offsets are x=0.2, y=0.3
+        px=np.zeros(n_part),
+        y=np.linspace(0.25, 0.35, n_part),
+        py=np.zeros(n_part),
+        zeta=np.zeros(n_part),
+        delta=np.zeros(n_part),
+    )
+
+    return particles
+
+
+def test_xtrack_rotation():
+    np.random.seed(seed=1994)
+
+    particles = make_particles()
+    g4man = cs.Geant4CollimationManager(collimator_file="resources/CollDB_testing.dat",
+                                        bdsim_config_file="resources/settings_black_absorber.gmad",
+                                        tfs_file="resources/twiss_file_testing.tfs",
+                                        reference_pdg_id=-11,
+                                        reference_kinetic_energy=0.510998946e6 * 10000,
+                                        emittance_norm=(1.e-6, 1.e-6),
+                                        relative_energy_cut=0.001,
+                                        seed=1993,
+                                        # batchMode=False
+                                        batchMode=True
+                                        )
+    
+    coll1 = g4man.make_xtg4_collimator("coll_skew") # Use new convenience method
+
+    # Generate a simple sequence
+    line = xt.Line(
+        elements=[coll1,
+                  ])
+
+    context = xo.ContextCpu() 
+    line.build_tracker(_context=context)
+
+    part_copy = particles.copy()
+    line.track(part_copy, num_turns=1)
+    
+    print(f"Lost particles: {sum(part_copy.state==-333)} / {len(part_copy.state)}")
+    assert sum(part_copy.state==-333) == 30
+
+    return part_copy
+
+
+def main():
+    part_g4 = test_xtrack_rotation()
+ 
+    # plt.scatter(part_g4.x, part_g4.y)
+    # plt.show()
+
+    print('Done!')
+
+
+if __name__ == '__main__':
+    main()

xcoll/scattering_routines/geant4/collimasim/tests/test_xtrack_colldb_load.py

@@ -0,0 +1,84 @@
+import numpy as np
+import collimasim as cs
+
+def test_yaml_colldb_load():
+    try: # yaml file loading is not implemented yet, so expect an error
+        g4man = cs.Geant4CollimationManager(collimator_file="resources/CollDB_yaml_example.yaml",
+                                            bdsim_config_file="resources/settings_black_absorber.gmad",
+                                            tfs_file="resources/twiss_file_testing.tfs",
+                                            reference_pdg_id=-11,
+                                            reference_kinetic_energy=182.4994890018054e9, # eV
+                                            emittance_norm=(0.000521429683675842, 1.0357164949725628e-06),
+                                            relative_energy_cut=0.001,
+                                            seed=1993,
+                                            batchMode=True)
+    except ValueError as e:
+        print(f"YAML file loading sucessfuly reports an error: {e}")
+
+
+def test_old_colldb_load():
+    g4man = cs.Geant4CollimationManager(collimator_file="resources/CollDB_old_example.dat",
+                                        bdsim_config_file="resources/settings_black_absorber.gmad",
+                                        tfs_file="resources/collonly_twiss_file_example.tfs",
+                                        reference_pdg_id=-11,
+                                        reference_kinetic_energy=182.4994890018054e9, # eV
+                                        emittance_norm=(0.000521429683675842, 1.0357164949725628e-06),
+                                        relative_energy_cut=0.001,
+                                        seed=1993,
+                                        batchMode=True)
+    assert np.isclose(g4man.collimators['tcp.a.b1']['halfgap'], 0.00976272689045678, atol=1e-10, rtol=1e-6)
+
+
+def test_new_colldb_load():
+    g4man = cs.Geant4CollimationManager(collimator_file="resources/CollDB_new_example.dat",
+                                        bdsim_config_file="resources/settings_black_absorber.gmad",
+                                        tfs_file="resources/collonly_twiss_file_example.tfs",
+                                        reference_pdg_id=-11,
+                                        reference_kinetic_energy=182.4994890018054e9, # eV
+                                        emittance_norm=(0.000521429683675842, 1.0357164949725628e-06),
+                                        relative_energy_cut=0.001,
+                                        seed=1993,
+                                        batchMode=True)
+    assert np.isclose(g4man.collimators['tcp.a.b1']['halfgap'], 0.00976272689045678, atol=1e-10, rtol=1e-6)
+
+
+def test_collgaps_load():
+    g4man = cs.Geant4CollimationManager(collimator_file="resources/collgaps.dat",
+                                        bdsim_config_file="resources/settings_black_absorber.gmad",
+                                        tfs_file="resources/collonly_twiss_file_example.tfs",
+                                        reference_pdg_id=-11,
+                                        reference_kinetic_energy=182.4994890018054e9, # eV
+                                        emittance_norm=(0.000521429683675842, 1.0357164949725628e-06),
+                                        relative_energy_cut=0.001,
+                                        seed=1993,
+                                        batchMode=True)
+    assert np.isclose(g4man.collimators['tcp.a.b1']['halfgap'], 0.00976272689045678, atol=1e-10, rtol=1e-6)
+
+
+def test_badfile_load():
+    try:
+        # This is an example of loading an invalid file
+        g4man = cs.Geant4CollimationManager(collimator_file="resources/settings.gmad",
+                                            bdsim_config_file="resources/settings_black_absorber.gmad",
+                                            tfs_file="resources/collonly_twiss_file_example.tfs",
+                                            reference_pdg_id=-11,
+                                            reference_kinetic_energy=182.4994890018054e9, # eV
+                                            emittance_norm=(0.000521429683675842, 1.0357164949725628e-06),
+                                            relative_energy_cut=0.001,
+                                            seed=1993,
+                                            batchMode=True)
+    except ValueError as e:
+         print(f"Invalid file loading sucessfuly reports an error: {e}")
+
+
+def main():
+    # test_yaml_colldb_load()
+    test_new_colldb_load()
+    # test_old_colldb_load()
+    # test_collgaps_load()
+    # test_badfile_load()
+
+if __name__ == '__main__':
+    main()
+
+

xcoll/scattering_routines/geant4/collimasim/tests/test_xtrack_interaction.py

@@ -0,0 +1,159 @@
+import numpy as np
+import xobjects as xo
+import xtrack as xt
+import xpart as xp
+
+import collimasim as cs
+
+import multiprocessing
+
+def test_fodo():
+    np.random.seed(seed=1994)
+
+    g4man = cs.Geant4CollimationManager(#collimator_file="resources/CollDB_new_example.dat",
+                                        #collimator_file="resources/CollDB_old_example.dat",
+                                        collimator_file="resources/collgaps.dat",
+                                        bdsim_config_file="resources/settings.gmad",
+                                        tfs_file="resources/collonly_twiss_file_example.tfs",
+                                        reference_pdg_id=-11,
+                                        reference_kinetic_energy=182.4994890018054e9, # eV
+                                        emittance_norm=(0.000521429683675842, 1.0357164949725628e-06),
+                                        relative_energy_cut=0.001,
+                                        seed=1993,
+                                        batchMode=True)
+
+    coll1 = g4man.make_xtg4_collimator("TCP.A.B1") # Use new convenience method
+    coll2 = g4man.make_xtg4_collimator("TCP.B.B1")
+
+    ## Generate a simple sequence
+    # The 1 m drift are split in 2 so the global aperture check at 1 m 
+    # can remove low-energy particles with large angles
+    line = xt.Line(
+        elements=[xt.Drift(length=0.5),
+                  xt.Drift(length=0.5),
+                  coll1,
+                  xt.Multipole(knl=[0, 1.], ksl=[0,0]),
+                  xt.Drift(length=0.5),
+                  xt.Drift(length=0.5),
+                  coll2,
+                  xt.Multipole(knl=[0, -1.], ksl=[0,0])
+                  ])
+
+
+    ## Chose a context
+    context = xo.ContextCpu()         # For CPU
+    # context = xo.ContectCupy()      # For CUDA GPUs
+    # context = xo.ContectPyopencl()  # For OpenCL GPUs
+
+    ## Transfer lattice on context and compile tracking code
+    line.config.global_xy_limit = 0.1
+    line.config.XTRACK_USE_EXACT_DRIFTS = True
+    line.build_tracker(_context=context)
+
+    ## Build particle object on context
+    n_part = 100
+    N_max_expected_products = 5000
+    n_turns = 3
+
+    tot_num_part = n_part + N_max_expected_products
+
+    particles = xp.Particles(
+        _capacity=tot_num_part,
+		p0c = 185.e9,
+        mass0 = xp.constants.ELECTRON_MASS_EV,
+        x=np.random.uniform(-1e-2, 1e-2, n_part),
+        px=np.random.uniform(-1e-5, 1e-5, n_part),
+        y=np.random.uniform(-2e-3, 2e-3, n_part),
+        py=np.random.uniform(-3e-5, 3e-5, n_part),
+        zeta=np.random.uniform(-1e-2, 1e-2, n_part),
+        delta=np.random.uniform(-1e-4, 1e-4, n_part),
+    )
+
+    ## Track (saving turn-by-turn data)
+    print(f"{particles._num_active_particles=}")
+    print(f"{particles._num_lost_particles=}")
+    print("turn=0")
+
+    for turn in range(n_turns):
+        line.track(particles, num_turns=1)
+
+        print(f"{particles._num_active_particles=}")
+        print(f"{particles._num_lost_particles=}")
+        print(f"{turn=}")
+
+        if particles._num_active_particles==0:
+            break
+
+    total_particles = particles._num_active_particles + particles._num_lost_particles
+    print(f"Surviving particles: {particles._num_active_particles} / {total_particles}")
+
+    # Allow 2 particle tolerance for rounding errors on different installation
+    assert np.isclose(sum(particles.state==1), 8, atol=2) # Active particles
+
+def main():
+    test_fodo()
+
+if __name__ == '__main__':
+    main()
+
+# The BDSIM link instances are no re-entry safe so can only run 1 test per file
+# If multiple instances are required, multiprocessing can offer a solution,
+# as spawned processes correctly handle the memory
+# Comment out the code below to try this functionality
+#  
+# def test_object():
+#     N_part = 10
+#     N_max_expected_products = 500
+#     tot_num_part = N_part + N_max_expected_products
+#     particles = xp.Particles(
+#         _capacity=tot_num_part,
+# 		p0c = 185.e9,
+#         x = np.zeros(N_part),
+# 		y = np.zeros(N_part),
+# 		zeta = np.zeros(N_part),
+# 		px = np.zeros(N_part),
+# 		py = np.zeros(N_part),
+# 		delta = np.zeros(N_part))
+#
+#     particles.x[1] = 0.3
+#     particles.x[4] = 0.3
+#
+#     print(particles.x)
+#
+#     g4man = cs.Geant4CollimationManager(collimator_file="resources/CollDB_old_example.dat",
+#                                         bdsim_config_file="resources/settings.gmad",
+#                                         tfs_file="resources/collonly_twiss_file_example.tfs",
+#                                         reference_pdg_id=-11,
+#                                         reference_kinetic_energy=182.4994890018054e9, # eV
+#                                         emittance_norm=(0.000521429683675842, 1.0357164949725628e-06),
+#                                         relative_energy_cut=0.001,
+#                                         seed=1993,
+#                                         batchMode=True)
+#
+#     coll1 = xt.BeamInteraction(interaction_process=cs.Geant4Collimator(name="tcp.a.b1",
+#                                                                        g4manager=g4man))
+#     coll2 = xt.BeamInteraction(interaction_process=cs.Geant4Collimator(name="tcp.a.b1",
+#                                                                        g4manager=g4man))
+#
+#     coll1.track(particles)
+#     coll2.track(particles)
+#
+#     print(f"Surviving after the second collimator: {sum(particles.state == 1)} / {particles.state}")
+#     assert sum(particles.state == 1) == 44 # Active particles
+#
+#
+# def main():
+#     # Initialising and de-allocating the collimasim extensions
+#     # may not clear up the memory properly. This seems to be a Python
+#     # limitation. Multiprocessing processes seem to solve this issue 
+#     p1 = multiprocessing.Process(target=test_object)
+#     p2 = multiprocessing.Process(target=test_fodo)
+#
+#     p1.start()
+#     p1.join()
+#
+#     p2.start()
+#     p2.join()
+#
+# if __name__ == '__main__':
+#     main()

xcoll/scattering_routines/geant4/collimasim/tests/test_xtrack_interaction_ion.py

@@ -0,0 +1,99 @@
+import numpy as np
+import xobjects as xo
+import xtrack as xt
+import xpart as xp
+
+import collimasim as cs
+
+import multiprocessing
+
+def test_fodo():
+    np.random.seed(seed=1994)
+
+    # Random parameters to get some scattering in the collimators
+    g4man = cs.Geant4CollimationManager(collimator_file="resources/CollDB_forions.dat",
+                                        bdsim_config_file="resources/settings_ions.gmad",
+                                        tfs_file="resources/collonly_twiss_file_example.tfs",
+                                        reference_pdg_id=xp.pdg.get_pdg_id_from_name('Pb208'),
+                                        reference_kinetic_energy=36706.8206525e9,
+                                        emittance_norm=(5e-5, 5e-5),
+                                        relative_energy_cut=0.001,
+                                        seed=1993,
+                                        batchMode=True)
+
+    ref_mass = g4man.g4link.getReferenceMass() * 1e9 # convert to eV
+
+    coll1 = g4man.make_xtg4_collimator("TCP.A.B1") # Use new convenience method
+    coll2 = g4man.make_xtg4_collimator("TCP.B.B1")
+
+    ## Generate a simple sequence
+    # The 1 m drift are split in 2 so the global aperture check at 1 m 
+    # can remove low-energy particles with large angles
+    line = xt.Line(
+        elements=[xt.Drift(length=0.5),
+                  xt.Drift(length=0.5),
+                  coll1,
+                  xt.Multipole(knl=[0, 1.], ksl=[0,0]),
+                  xt.Drift(length=0.5),
+                  xt.Drift(length=0.5),
+                  coll2,
+                  xt.Multipole(knl=[0, -1.], ksl=[0,0])
+                  ])
+
+
+    ## Chose a context
+    context = xo.ContextCpu()         # For CPU
+    # context = xo.ContectCupy()      # For CUDA GPUs
+    # context = xo.ContectPyopencl()  # For OpenCL GPUs
+
+    ## Transfer lattice on context and compile tracking code
+    line.config.global_xy_limit = 0.1
+    line.config.XTRACK_USE_EXACT_DRIFTS = True
+    line.build_tracker(_context=context)
+
+    ## Build particle object on context
+    n_part = 100
+    N_max_expected_products = 50000
+    n_turns = 3
+
+    tot_num_part = n_part + N_max_expected_products
+
+    particles = xp.Particles(
+        _capacity=tot_num_part,
+		p0c = 36900e9,
+        mass0 = ref_mass,
+        x=np.random.uniform(-1e-2, 1e-2, n_part),
+        px=np.random.uniform(-1e-5, 1e-5, n_part),
+        y=np.random.uniform(-2e-3, 2e-3, n_part),
+        py=np.random.uniform(-3e-5, 3e-5, n_part),
+        zeta=np.random.uniform(-1e-2, 1e-2, n_part),
+        delta=np.random.uniform(-1e-4, 1e-4, n_part),
+        pdg_id=np.full(n_part, xp.pdg.get_pdg_id_from_name('Pb208'))
+    )
+
+    ## Track (saving turn-by-turn data)
+    print(f"{particles._num_active_particles=}")
+    print(f"{particles._num_lost_particles=}")
+    print("turn=0")
+
+    for turn in range(n_turns):
+        line.track(particles, num_turns=1)
+
+        print(f"{particles._num_active_particles=}")
+        print(f"{particles._num_lost_particles=}")
+        print(f"{turn=}")
+
+        if particles._num_active_particles==0:
+            break
+
+    total_particles = particles._num_active_particles + particles._num_lost_particles
+    print(f"Surviving particles: {particles._num_active_particles} / {total_particles}")
+
+    # Allow 1 particle tolerance for rounding errors on different installation
+    assert np.isclose(sum(particles.state==1), 1143, atol=1) # Active particles
+
+def main():
+    test_fodo()
+
+if __name__ == '__main__':
+    main()

xcoll/scattering_routines/geant4/collimasim/tests/test_xtrack_ions.py

@@ -0,0 +1,78 @@
+import numpy as np
+import xtrack as xt
+import xpart as xp
+
+import collimasim as cs
+
+
+def test_object_creation():
+    N_part = 10
+    N_max_expected_products = 10
+
+    tot_num_part = N_part
+
+    particles = xp.Particles(
+		p0c = 36900e9,
+        x = np.zeros(tot_num_part),
+		y = np.zeros(tot_num_part),
+		zeta = np.zeros(tot_num_part),
+		px = np.zeros(tot_num_part),
+		py = np.zeros(tot_num_part),
+		delta = np.zeros(tot_num_part))
+
+    particles.num_particles = N_part
+
+    particles.x[1] = 0.3
+    particles.y[2] = 0.3
+
+    # Random parameters to get some scattering in the collimators
+    g4man = cs.Geant4CollimationManager(collimator_file="resources/CollDB_forions.dat",
+                                        bdsim_config_file="resources/settings_ions.gmad",
+                                        tfs_file="resources/collonly_twiss_file_example.tfs",
+                                        reference_pdg_id=xp.pdg.get_pdg_id_from_name('Pb208'),
+                                        reference_kinetic_energy=36706.8206525e9,
+                                        emittance_norm=(0.000521429683675842, 0.000521429683675842),
+                                        relative_energy_cut=0.001,
+                                        seed=1993,
+                                        batchMode=True)
+
+    coll1 = cs.Geant4Collimator(name="tcp.a.b1", g4manager=g4man)
+    coll2 = cs.Geant4Collimator(name="tcp.b.b1", g4manager=g4man)
+
+
+    print("Particle coordinates (x) before first collimator")
+    print (particles.delta)
+
+    prods = coll1.interact(particles)
+
+    print("Particle coordinates (x) after first collimator")
+    print (particles.x)
+    print (particles.y)
+
+    print("="*30)
+    print("Products:")
+    for crd in prods:
+        print(crd, ":", prods[crd])
+    print("="*30)
+
+    prods = coll2.interact(particles)
+
+    print("Particle coordinates (x) after second collimator")
+    print (particles.x)
+    print (particles.y)
+
+    print("="*30)
+    print("Products:")
+    for crd in prods:
+        print(crd, ":", prods[crd])
+    print("="*30)
+
+    assert len(prods['x']) == 59
+
+
+def main():
+    test_object_creation()
+
+
+if __name__ == '__main__':
+    main()

xcoll/scattering_routines/geant4/collimasim/tests/test_xtrack_lost_energy.py

@@ -0,0 +1,88 @@
+import numpy as np
+import xtrack as xt
+import xpart as xp
+
+import collimasim as cs
+import pandas as pd
+
+def test_energy_diffrential():
+    N_part = 10
+    N_max_expected_products = 10
+
+    particles = xp.Particles(
+        _capaccity = N_part,
+		p0c = 36900e9,
+        x = np.zeros(N_part),
+		y = np.zeros(N_part),
+		zeta = np.zeros(N_part),
+		px = np.zeros(N_part),
+		py = np.zeros(N_part),
+		delta = np.zeros(N_part),
+        pdg_id = xp.pdg.get_pdg_id_from_name('Pb208'),
+        mass0=193687676197.13638,
+        )
+
+    particles.x[1] = 0.04226982005192951 + 10e-6
+    particles.px[1] = 1e-7
+    particles.x[2] = -0.04226982005192951 - 10e-6
+    particles.px[2] = -1e-7
+    particles.x[3] = 0.04226982005192951 + 10e-6
+    particles.y[4] = 0.05
+
+    part_orig = particles.copy()
+
+    # Random parameters to get some scattering in the collimators
+    g4man = cs.Geant4CollimationManager(collimator_file="resources/CollDB_forions.dat",
+                                        bdsim_config_file="resources/settings_ions.gmad",
+                                        tfs_file="resources/collonly_twiss_file_example.tfs",
+                                        reference_pdg_id=xp.pdg.get_pdg_id_from_name('Pb208'),
+                                        reference_kinetic_energy=36706.8206525e9,
+                                        emittance_norm=(0.000521429683675842, 0.000521429683675842),
+                                        relative_energy_cut=0.0001,
+                                        seed=1993,
+                                        batchMode=True)
+
+    coll1 = cs.Geant4Collimator(name="tcp.a.b1", g4manager=g4man)
+
+
+    prods = coll1.interact(particles)
+
+    part_df = particles.to_pandas(compact=True)
+    part_orig_df = part_orig.to_pandas(compact=True)
+
+    part_mass_ratio = part_df.charge_ratio / part_df.chi
+    part_mom = (part_df.delta + 1) * part_df.p0c * part_mass_ratio
+    part_mass = part_mass_ratio * part_df.mass0
+    part_tot_energy = np.sqrt(part_mom**2 + part_mass**2)
+    part_df['energy'] = part_tot_energy
+
+    part_orig_mass_ratio = part_orig_df.charge_ratio / part_orig_df.chi
+    part_orig_mom = (part_orig_df.delta + 1) * part_orig_df.p0c * part_orig_mass_ratio
+    part_orig_mass = part_orig_mass_ratio * part_orig_df.mass0
+    part_orig_tot_energy = np.sqrt(part_orig_mom**2 + part_orig_mass**2)
+    part_orig_df['energy'] = part_tot_energy
+
+    prod_df = pd.DataFrame(prods)
+
+    prod_mass_ratio = prod_df.mass_ratio
+    prod_mom = (prod_df.delta + 1) * part_df.p0c[0] * prod_mass_ratio
+    prod_mass = prod_mass_ratio * part_df.mass0[0]
+    prod_tot_energy = np.sqrt(prod_mom**2 + prod_mass**2)
+    prod_df['energy'] = prod_tot_energy
+
+    for part_id in [1, 2, 3]:
+        pp = part_df[part_df['particle_id'] == part_id]
+        pp_orig = part_df[part_orig_df['particle_id'] == part_id]
+        prods_pp = prod_df[prod_df['parent_particle_id'] == part_id]
+
+        combined_energy = float(pp['energy']) + float(sum(prods_pp['energy']))
+        energy_diff = combined_energy - float(pp_orig['energy'])
+
+
+
+def main():
+    test_energy_diffrential()
+
+
+if __name__ == '__main__':
+    main()

xcoll/scattering_routines/geant4/collimasim/tests/test_xtrack_tilt.py

@@ -0,0 +1,80 @@
+import numpy as np
+import xobjects as xo
+import xtrack as xt
+import xpart as xp
+
+import collimasim as cs
+from matplotlib import pyplot as plt
+
+import multiprocessing
+
+def make_particles():
+    np.random.seed(seed=1994)
+    n_part = 100
+    particles = xp.Particles(
+        _capacity=n_part,
+		p0c = 1.e3, # 1 KeV dummy particles
+        mass0 = xp.ELECTRON_MASS_EV,
+        x=np.linspace(0.1, 0.3, n_part), # Offsets are x=0.2, y=0.3
+        #x=np.random.uniform(0.1, 0.3, n_part), # Offsets are x=0.2, y=0.3
+        px=np.zeros(n_part),
+        y=np.linspace(0.2, 0.4, n_part),
+        #y=np.random.uniform(0.2, 0.4, n_part),
+        #y=np.zeros(n_part) + 0.3,
+        py=np.zeros(n_part),
+        zeta=np.zeros(n_part),
+        delta=np.zeros(n_part),
+    )
+
+    return particles
+
+
+def test_xtrack_tilt():
+    np.random.seed(seed=1994)
+    particles = make_particles()
+
+    g4man = cs.Geant4CollimationManager(collimator_file="resources/CollDB_testing.dat",
+                                        bdsim_config_file="resources/settings_black_absorber.gmad",
+                                        tfs_file="resources/twiss_file_testing.tfs",
+                                        reference_pdg_id=-11,
+                                        reference_kinetic_energy=0.510998946e6 * 10000,
+                                        emittance_norm=(1.e-6, 1.e-6),
+                                        relative_energy_cut=0.001,
+                                        seed=1993,
+                                        # batchMode=False
+                                        batchMode=True
+                                        )
+    
+    coll1 = g4man.make_xtg4_collimator("coll_skew_tilted") # Use new convenience method
+
+    # Generate a simple sequence
+    line = xt.Line(
+        elements=[coll1,
+                  ])
+
+    context = xo.ContextCpu()
+    line.build_tracker(_context=context)
+
+    part_copy = particles.copy()
+    line.track(part_copy, num_turns=1)
+    
+    print(f"Lost particles: {sum(part_copy.state==-333)} / {len(part_copy.state)}")
+    assert sum(part_copy.state==-333) == 89
+
+    return part_copy
+
+
+def main():
+    part_g4 = test_xtrack_tilt()
+
+    # plt.scatter(part_g4.x, part_g4.y, c=part_g4.state)
+    # ax = plt.gca()
+    # ax.axvline(0.15, c='r')
+    # ax.axvline(0.25, c='r')
+    # plt.show()
+
+    print('Done!')
+
+
+if __name__ == '__main__':
+    main()