xcoll 0.5.12__py3-none-any.whl → 0.6.1__py3-none-any.whl

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

@@ -1,74 +0,0 @@
-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

@@ -1,84 +0,0 @@
-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

@@ -1,159 +0,0 @@
-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

@@ -1,99 +0,0 @@
-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

@@ -1,78 +0,0 @@
-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

@@ -1,88 +0,0 @@
-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

@@ -1,80 +0,0 @@
-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()