xtrack 0.79.5__tar.gz → 0.80.1__tar.gz

{xtrack-0.79.5/xtrack.egg-info → xtrack-0.80.1}/PKG-INFO

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

xtrack-0.80.1/tests/test_electron_cooler.py

@@ -0,0 +1,212 @@
+# copyright ############################### #
+# This file is part of the Xtrack Package.  #
+# Copyright (c) CERN, 2021.                 #
+# ######################################### #
+
+import numpy as np
+import pytest
+import pathlib
+from cpymad.madx import Madx
+from scipy.stats import linregress
+from scipy import constants as cst
+import ducktrack as dtk
+import xobjects as xo
+import xpart as xp
+import xtrack as xt
+from xobjects.test_helpers import for_all_test_contexts, fix_random_seed
+from xtrack.beam_elements.elements import _angle_from_trig
+
+test_data_folder = pathlib.Path(
+    __file__).parent.joinpath('../test_data').absolute()
+
+
+@for_all_test_contexts
+def test_ecooler_emittance(test_context):
+    """Test the electron cooler by comparing the cooling rate with Betacool for LEIR.
+    """
+    data = np.load(test_data_folder/'electron_cooler/emittance_betacool.npz')
+    emittance_betacool = data['emittance']
+    time_betacool = data['time']
+
+    gamma0 = 1.004469679
+    beta0 = np.sqrt(1 - 1 / gamma0**2)
+    mass0 = 193729.0248722061 * 1e6  # eV/c^2
+    clight = 299792458.0
+    p0c = mass0 * beta0 * gamma0  # eV/c
+    q0 = 54
+    particle_ref = xp.Particles(p0c=p0c,q0=q0,mass0=mass0,beta0=beta0,gamma0=gamma0)
+
+    circumference = 78.54370266  # m
+    T_per_turn = circumference/(clight*beta0)
+
+    qx = 1.82
+    qy = 2.72
+    beta_x = 5
+    beta_y = 5
+    qs=0.005247746218929317
+    bets0=-2078.673348423543
+
+    arc = xt.LineSegmentMap(
+            qx=qx, qy=qy,
+            length=circumference,
+            betx=beta_x,
+            bety=beta_y,
+            )
+
+    arc_matching = xt.LineSegmentMap(
+            qx=qx, qy=qy,
+            length=circumference,
+            betx=beta_x,
+            bety=beta_y,
+            qs=qs,
+            bets=bets0)
+
+    line_matching=xt.Line([arc_matching])
+    line_matching.build_tracker()
+
+    num_particles=int(1e2)
+    sigma_dp = 5e-3    
+    gemitt_x = 14e-6
+    gemitt_y = 14e-6
+
+    nemitt_x = gemitt_x*beta0*gamma0
+    nemitt_y = gemitt_y*beta0*gamma0
+
+    particles = xp.generate_matched_gaussian_bunch(
+            num_particles=num_particles,
+            nemitt_x=nemitt_x, nemitt_y=nemitt_y, sigma_z=4.2,
+            particle_ref=particle_ref,
+            line=line_matching,        
+            )
+
+    particles.delta = np.random.normal(loc=0.0, scale=sigma_dp, size=num_particles)
+    particles.zeta = np.random.uniform(-circumference/2, circumference/2, num_particles)
+
+    max_time_s = 1
+    int_time_s = 1*1e-3
+    num_turns = int((max_time_s / T_per_turn).item())
+    save_interval = int((int_time_s / T_per_turn).item())
+
+    monitor = xt.ParticlesMonitor(start_at_turn=0, stop_at_turn=1,
+                            n_repetitions=int(num_turns/save_interval),
+                            repetition_period=save_interval,
+                            num_particles=len(particles.x))
+
+    current = 0.6  # amperes
+    cooler_length = 2.5  # m cooler length
+    radius_e_beam = 25 * 1e-3
+    temp_perp = 100e-3 # <E> [eV] = kb*T
+    temp_long =  1e-3 # <E> [eV]
+    magnetic_field = 0.075  # T for LEIR
+
+    electron_cooler = xt.ElectronCooler(current=current,
+                                    length=cooler_length,
+                                    radius_e_beam=radius_e_beam,
+                                    temp_perp=temp_perp, temp_long=temp_long,
+                                    magnetic_field=magnetic_field)
+
+    line = xt.Line(elements=[monitor, electron_cooler, arc],element_names=['monitor','electron_cooler','arc'])                                    
+    line.particle_ref = particle_ref
+    line.build_tracker()
+
+    line.track(particles, num_turns=num_turns,
+            turn_by_turn_monitor=False,with_progress=True)
+
+    x = monitor.x[:,:,0]
+    px = monitor.px[:,:,0]
+    time = monitor.at_turn[:, 0, 0] * T_per_turn
+
+    action_x = (x**2/beta_x + beta_x*px**2)
+    geo_emittance_x=np.mean(action_x,axis=1)/2
+
+    # Match Betacool and Xsuite indices to compare emittance
+    valid_indices = ~np.isnan(time_betacool)
+    time_betacool = time_betacool[valid_indices]
+    matched_indices = [np.abs(time - tb).argmin() for tb in time_betacool]
+    emittance_xsuite = geo_emittance_x[matched_indices]
+    emittance_betacool = emittance_betacool[:len(emittance_xsuite)]
+    
+    xo.assert_allclose(emittance_xsuite, emittance_betacool, rtol=0, atol=1e-5)
+   
+@for_all_test_contexts
+def test_ecooler_force(test_context):
+    """Test the electron cooler by comparing the cooling force with Betacool for LEIR.
+    """
+    # Load Betacool force data
+    data_betacool = np.load(test_data_folder/'electron_cooler/force_betacool.npz')
+    v_diff_betacool = data_betacool['v_diff']
+    force_betacool = data_betacool['force']
+
+    beta_rel = 0.09423258405
+    gamma = 1.004469679
+    current = 0.6  # Amperes
+    cooler_length = 2.5  # m
+    radius_e_beam = 25 * 1e-3  # m
+    temp_perp = 100e-3  # eV
+    temp_long = 1e-3  # eV
+    magnetic_field = 0.075  # T for LEIR
+    mass0 = 193729.0248722061 * 1e6  # eV/c^2
+    clight = 299792458.0  # m/s
+    p0c = mass0 * beta_rel * gamma  # eV/c
+    q0 = 54  # Charge
+    beta_x = 5  # m
+    emittance = 14 * 1e-6  # Initial geometric emittance (m·rad)
+
+    # Reference particle
+    particle_ref = xp.Particles(p0c=p0c, mass0=mass0, q0=q0)
+
+    # Electron cooler
+    cooler = xt.ElectronCooler(
+        current=current,
+        length=cooler_length,
+        radius_e_beam=radius_e_beam,
+        temp_perp=temp_perp,
+        temp_long=temp_long,
+        magnetic_field=magnetic_field,
+        record_flag=1
+    )  
+    
+    num_particles = int(1e4)
+    particles = xp.Particles(
+        mass0=mass0,
+        p0c=p0c,
+        q0=q0,
+        x=np.random.normal(0, 1e-20, num_particles),
+        px=np.random.normal(0, 4 * np.sqrt(emittance / beta_x), num_particles),
+        y=np.random.normal(0, 1e-20, num_particles),
+        py=np.random.normal(0, 1e-20, num_particles),
+        delta=np.zeros(num_particles),
+        zeta=np.zeros(num_particles)
+    )
+   
+    line = xt.Line(elements=[cooler])
+    line.particle_ref = particle_ref
+    line.build_tracker()
+
+    # Start internal logging for the electron cooler
+    record = line.start_internal_logging_for_elements_of_type(
+        xt.ElectronCooler, capacity=10000)
+
+    line.track(particles)
+    force = record.Fx
+    particle_id=record.particle_id[:num_particles]
+    particle_id_sort=np.argsort(particle_id)
+
+    force=force[particle_id_sort]
+
+    px_tot = p0c * particles.px
+    beta_diff = px_tot / (mass0 * gamma)
+    v_diff = beta_diff * clight
+    
+    sorted_indices = np.argsort(v_diff)
+    v_diff = v_diff[sorted_indices]
+    force = force[sorted_indices]
+
+    # Match Betacool and Xsuite indices to compare forces
+    v_diff_betacool = v_diff_betacool[~np.isnan(v_diff_betacool)]
+    matching_indices = [np.abs(v_diff - vb).argmin() for vb in v_diff_betacool]
+
+    force_xsuite = np.array([force[i] for i in matching_indices])
+    force_betacool = force_betacool[:len(v_diff_betacool)]
+
+    xo.assert_allclose(force_xsuite, force_betacool, rtol=0, atol=10)

{xtrack-0.79.5 → xtrack-0.80.1}/tests/test_elements.py

@@ -5,6 +5,7 @@
 
 import numpy as np
 import pytest
+import pathlib
 from cpymad.madx import Madx
 from scipy.stats import linregress
 from scipy import constants as cst
@@ -15,6 +16,9 @@ import xtrack as xt
 from xobjects.test_helpers import for_all_test_contexts, fix_random_seed
 from xtrack.beam_elements.elements import _angle_from_trig
 
+test_data_folder = pathlib.Path(
+    __file__).parent.joinpath('../test_data').absolute()
+
 
 @for_all_test_contexts
 def test_constructor(test_context):
@@ -43,6 +47,8 @@ def test_constructor(test_context):
                    sampling_frequency=1e3),
         xt.Bend(_context=test_context, length=1.),
         xt.Quadrupole(_context=test_context, length=1.),
+        xt.ElectronCooler(_context=test_context,current=2.4,length=1.5,radius_e_beam=25*1e-3,
+                                temp_perp=0.01,temp_long=0.001,magnetic_field=0.060) 
     ]
 
     # test to_dict / from_dict
@@ -1246,3 +1252,5 @@ def test_multipole_tilt_90_deg(test_context):
     xo.assert_allclose(pf.py, pfy.py, rtol=0, atol=1e-14)
     xo.assert_allclose(pf.zeta, pfy.zeta, rtol=0, atol=1e-14)
     xo.assert_allclose(pf.ptau, pfy.ptau, rtol=0, atol=1e-14)
+
+

{xtrack-0.79.5 → xtrack-0.80.1}/tests/test_ions.py

@@ -11,6 +11,50 @@ test_data_folder = pathlib.Path(
         __file__).parent.joinpath('../test_data').absolute()
 
 
+
+
+@for_all_test_contexts
+def test_chi(test_context):
+    ''' Tests if particles are deflected in quadrupoles according to their chi value.'''
+
+    quad1 = xt.Quadrupole(knl=[0,-0.005])
+    ql    = xt.Line(
+                elements      = [xt.Drift(length=10), quad1,    xt.Drift(length=100)],
+                element_names = ['drift_0', 'quad_0', 'drift_1'])
+    
+
+    ql.build_tracker(_context = test_context)
+
+    print(f"Test {test_context.__class__}")
+
+    z0              = 82
+    z               = 82
+    m               = 192755492342.6663   # pb207
+    m0              = 193687690162.6481
+    ql.particle_ref = xp.Particles(p0c=6.8e12*z0 , q0=z0, mass0=m0)
+
+    # reference species with effective rigidity
+    part1           = ql.particle_ref.copy(_context=test_context)
+    delta           = 0
+    chi             = (z0/z)*(m/m0)
+    part1.delta     = (1 + delta)/(chi) - 1
+
+    # pb207
+    part2              = ql.particle_ref.copy(_context=test_context)
+    part2.chi          = (z0/z)*(m/m0)
+    part2.charge_ratio = (z/z0)
+
+    # 
+    x0        = 0.0001
+    part1.x   = x0
+    part2.x   = x0
+
+    ql.track(part1)
+    ql.track(part2)
+
+    xo.assert_allclose(part1.x[0], part2.x[0], rtol=0, atol=1e-6)
+
+
 @for_all_test_contexts
 def test_ions(test_context):
 

{xtrack-0.79.5 → xtrack-0.80.1}/tests/test_native_madloader.py

@@ -45,81 +45,74 @@ def test_simple_parser():
     return;  ! should also be ignored
     """
 
-    expected: MadxOutputType = {
-        'vars': {
-            'third': {'deferred': False, 'expr': '(1.0 / 3.0)'},
-            'power': {'deferred': False, 'expr': '(3.0 ** 4.0)'},
-            'hello': {'deferred': True, 'expr': '(third * twopi)'},
-            'mb.l': {'deferred': False, 'expr': 1.0},
-            'qd.l': {'deferred': False, 'expr': 0.5},
-            'offset': {'deferred': True, 'expr': 0.1},
-        },
+    env = xt.Environment()
+    env['twopi'] = 2 * math.pi
+    parser = MadxParser(vars=env.vars, functions=env.functions)
+    result = parser.parse_string(sequence)
+
+    expected = {
         'elements': {
             'mb': {
-                'angle': {'deferred': True, 'expr': 'hello'},
-                'l': {'deferred': True, 'expr': 'mb.l'},
+                'angle': env.vars['hello'],
+                'l': env.vars['mb.l'],
                 'parent': 'sbend',
             },
             'qf': {
-                'k1': {'deferred': True, 'expr': 1.0},
-                'l': {'deferred': True, 'expr': 1.0},
+                'k1': 1.0,
+                'l': 1.0,
                 'parent': 'quadrupole',
             },
             'qd': {
-                'k1': {'deferred': True, 'expr': -1.0},
-                'l': {'deferred': True, 'expr': 1.0},
+                'k1': -1.0,
+                'l': 1.0,
                 'parent': 'quadrupole',
             },
         },
         'lines': {
             'line': {
-                'l': {'deferred': False, 'expr': 12.0},
+                'l': 12.0,
                 'parent': 'sequence',
                 'elements': {
                     'ip1': {
-                        'at': {'deferred': False, 'expr': 0.0},
+                        'at': 0.0,
                         'parent': 'marker',
                     },
                     'qf1': {
-                        'at': {'deferred': True, 'expr': '(1.0 + offset)'},
-                        'from': {'deferred': False, 'expr': 'ip1'},
+                        'at': 1.0 + env.vars['offset'],
+                        'from': 'ip1',
                         'parent': 'qf',
-                        'slot_id': {'deferred': False, 'expr': 1.0},
+                        'slot_id': 1.0,
                     },
                     'mb1': {
-                        'at': {'deferred': True, 'expr': '(2.0 + offset)'},
-                        'from': {'deferred': False, 'expr': 'ip1'},
+                        'at': 2.0 + env.vars['offset'],
+                        'from': 'ip1',
                         'parent': 'mb',
-                        'slot_id': {'deferred': False, 'expr': 2.0},
+                        'slot_id': 2.0,
                     },
                     'qd1': {
-                        'at': {'deferred': True, 'expr': '(3.0 + offset)'},
-                        'from': {'deferred': False, 'expr': 'ip1'},
+                        'at': 3.0 + env.vars['offset'],
+                        'from': 'ip1',
                         'parent': 'qd',
-                        'slot_id': {'deferred': False, 'expr': 3.0},
+                        'slot_id': 3.0,
                     },
                 },
             },
         },
         'parameters': {
             'mb1': {
-                'k0': {'deferred': True, 'expr': 'hello'},
-                'polarity': {'deferred': False, 'expr': 1.0},
+                'k0': env.vars['hello'],
+                'polarity': 1.0,
             },
             'qf1': {
-                'knl': {'deferred': True, 'expr': [0.0, 0.0, 0.0, 0.01, 0.0]},
+                'knl': [0.0, 0.0, 0.0, 0.01, 0.0],
             },
             'qd1': {
-                'knl': {'deferred': True, 'expr': [0.0, 0.0, 0.0, -0.01, 0.0]},
+                'knl': [0.0, 0.0, 0.0, -0.01, 0.0],
             },
         },
     }
 
-    parser = MadxParser()
-    result = parser.parse_string(sequence)
-
     def _order_madx_output(item):
-        item['vars'] = OrderedDict(item['vars'])
         item['elements'] = OrderedDict(item['elements'])
         item['lines'] = OrderedDict(item['lines'])
         for line in item['lines'].values():
@@ -137,6 +130,7 @@ def test_simple_parser():
     [
         ('a := 42;', 42, None),
         ('c := 3; d := 4; a := c^d;', 81, '(c ** d)'),
+        ('c := 3; d := 4; a = c^d;', 81, None),
     ]
 )
 def test_parse_simple_expression(input, value, expr):
@@ -146,6 +140,10 @@ def test_parse_simple_expression(input, value, expr):
     if expr is not None:
         formatter = CompactFormatter(None)
         assert env.get_expr('a')._formatted(formatter) == expr
+    else:
+        assert env.get_expr('a') is None
+        env['c'] = 8
+        assert env['a'] == value
 
 
 @pytest.fixture(scope='module')
@@ -890,13 +888,12 @@ def test_import_seq_length():
     sequence = """
     qu: quadrupole, l=2, k1=3, k1s=4, tilt=2;  ! ignore thick and ktap
 
-    line: sequence, l = ll;
-        qu1: qu, at = 19;
-    endsequence;
-
     ll := 3 * a;
     a = 10;
 
+    line: sequence, l = ll;
+        qu1: qu, at = 19;
+    endsequence;
     """
 
     env = xt.load_madx_lattice(string=sequence)
@@ -904,7 +901,7 @@ def test_import_seq_length():
     tt = env.line.get_table()
     assert np.all(tt.name == np.array(['drift_1', 'qu1', 'drift_2', '_end_point']))
     xo.assert_allclose(tt['s'], np.array([ 0., 18., 20., 30.]), rtol=0, atol=1e-15)
-    assert env.line.builder.length == 'll'
+    assert env.line.builder.length == 30
 
 
 def test_repeated_element_mad_behaviour():

xtrack-0.80.1/tests/test_optimize_for_tracking.py

@@ -0,0 +1,79 @@
+import xtrack as xt
+import xpart as xp
+
+def test_optimize_with_radiation():
+    
+    env = xt.Environment()
+
+    env.new('mb', xt.Bend, length=1, k0=1, h=1)
+    env.new('mq', xt.Quadrupole, length=1, k1=1)
+    env.new('ms', xt.Sextupole, length=1, k2=1)
+    env.new('mo', xt.Octupole, length=1, k3=1)
+
+    element_list = ['mb', 'mq', 'ms', 'mo']
+
+    for element in element_list:
+        line = env.new_line(components=[element])
+        
+        line.slice_thick_elements(
+            slicing_strategies=[xt.Strategy(slicing=xt.Teapot(1))])
+        
+        line.build_tracker()
+        line.configure_radiation('mean')
+        
+        part = xp.Particles(p0c=1e15, x=0.11)
+        line.track(part)
+        
+        line.optimize_for_tracking()
+        part_opt = xp.Particles(p0c=1e15, x=0.11)
+        line.track(part_opt)
+        
+        assert part.x == part_opt.x
+        assert part.y == part_opt.y
+        assert part.px == part_opt.px
+        assert part.py == part_opt.py
+        assert part.zeta == part_opt.zeta
+        assert part.pzeta == part_opt.pzeta
+
+def test_optimize_with_delta_taper():
+    
+    env = xt.Environment()
+
+    env.new('mb', xt.Bend, length=1, k0=1, h=1)
+    env.new('mq', xt.Quadrupole, length=1, k1=1)
+    env.new('ms', xt.Sextupole, length=1, k2=1)
+    env.new('mo', xt.Octupole, length=1, k3=1)
+
+    thin_classes = [xt.ThinSliceBendEntry, xt.ThinSliceBendExit, xt.ThinSliceBend, 
+                    xt.ThinSliceQuadrupole, xt.ThinSliceSextupole, xt.ThinSliceOctupole]
+
+    element_list = ['mb', 'mq', 'ms', 'mo']
+
+    for element in element_list:
+        line = env.new_line(components=[element])
+        
+
+        line.slice_thick_elements(
+            slicing_strategies=[xt.Strategy(slicing=xt.Teapot(1))])
+
+        for el in line.elements:
+            if type(el) in thin_classes:
+                el.delta_taper = 0.1
+                print(el)
+        
+        line.build_tracker()
+        line.configure_radiation('mean')
+        
+        part = xp.Particles(p0c=1e15, x=0.11)
+        line.track(part)
+        
+        line.optimize_for_tracking()
+        part_opt = xp.Particles(p0c=1e15, x=0.11)
+        line.track(part_opt)
+        
+        assert part.x == part_opt.x
+        assert part.y == part_opt.y
+        assert part.px == part_opt.px
+        assert part.py == part_opt.py
+        assert part.zeta == part_opt.zeta
+        assert part.pzeta == part_opt.pzeta

xtrack-0.80.1/xtrack/_version.py

@@ -0,0 +1 @@
+__version__ = '0.80.1'

{xtrack-0.79.5 → xtrack-0.80.1}/xtrack/beam_elements/elements.py

@@ -21,6 +21,8 @@ from xtrack.beam_elements.magnets import (
     DEFAULT_MULTIPOLE_ORDER, SynchrotronRadiationRecord, _prepare_multipolar_params,
     _NOEXPR_FIELDS, COMMON_MAGNET_SOURCES
 )
+from xtrack.internal_record import RecordIndex
+
 
 class ReferenceEnergyIncrease(BeamElement):
 
@@ -3195,6 +3197,121 @@ class SecondOrderTaylorMap(BeamElement):
 
         return out
 
+class ElectronCoolerRecord(xo.HybridClass):
+    _xofields = {
+        '_index': RecordIndex,
+        'Fx': xo.Float64[:],
+        'Fy': xo.Float64[:],
+        'Fl': xo.Float64[:],
+        'particle_id': xo.Float64[:]}
+class ElectronCooler(BeamElement):
+    """
+    Beam element modeling an electron cooler. In particular, this beam element uses the Parkhomchuk model for electron cooling.
+    Every turn each particle receives transverse and longitudinal kicks based on the cooling force provided by the Parkhomchuk model.
+
+
+    Parameters
+        ----------
+        current : float, optional
+            The current in the electron beam, in amperes.
+        length  : float, optional
+            The length of the electron cooler, in meters.
+        radius_e_beam : float, optional
+            The radius of the electron beam, in meters.
+        temp_perp : float, optional
+            The transverse temperature of the electron beam, in electron volts.
+        temp_long : float, optional
+            The longitudinal temperature of the electron beam, in electron volts.
+        magnetic_field : float, optional
+            The magnetic field strength, in tesla.
+        offset_x : float, optional
+            The horizontal offset of the electron cooler, in meters.
+        offset_px : float, optional
+            The horizontal angle of the electron cooler, in rad.
+        offset_y : float, optional
+            The horizontal offset of the electron cooler, in meters.    
+        offset_py : float, optional
+            The vertical angle of the electron cooler, in rad.
+        offset_energy : float, optional
+            The energy offset of the electrons, in eV.
+        magnetic_field_ratio : float, optional
+            The ratio of perpendicular component of magnetic field with the 
+            longitudinal component of the magnetic field. This is a measure
+            of the magnetic field quality. With the ideal magnetic field quality 
+            being 0.
+        space_charge : float, optional
+            Whether space charge of electron beam is enabled. 0 is off and 1 is on.
+        
+    """
+
+    _xofields = {
+        'current'       :  xo.Float64,
+        'length'        :  xo.Float64,
+        'radius_e_beam' :  xo.Float64,
+        'temp_perp'     :  xo.Float64,
+        'temp_long'     :  xo.Float64,
+        'magnetic_field':  xo.Float64,
+                
+        'offset_x'      :  xo.Float64,
+        'offset_px'     :  xo.Float64,
+        'offset_y'      :  xo.Float64,
+        'offset_py'     :  xo.Float64,
+        'offset_energy' :  xo.Float64,
+
+        'magnetic_field_ratio' :  xo.Float64,
+        'space_charge_factor'  : xo.Float64,
+        'record_flag': xo.Int64,
+        }
+    
+    _extra_c_sources = [
+        _pkg_root.joinpath('headers/constants.h'),
+        _pkg_root.joinpath('beam_elements/elements_src/electroncooler.h')]
+    
+    _internal_record_class = ElectronCoolerRecord
+
+    def __init__(self,  current        = 0,
+                        length         = 0,
+                        radius_e_beam  = 0,
+                        temp_perp      = 0,
+                        temp_long      = 0,
+                        magnetic_field = 0,
+
+                        offset_x       = 0,
+                        offset_px      = 0,
+                        offset_y       = 0,
+                        offset_py      = 0,
+                        offset_energy  = 0,
+                                                
+                        magnetic_field_ratio = 0,
+                        space_charge_factor  = 0,
+                        record_flag          =0,                      
+                        **kwargs):
+        
+        if "_xobject" in kwargs:
+            self.xoinitialize(_xobject=kwargs['_xobject'])
+            return
+        
+        super().__init__(**kwargs)
+        self.current        = current
+        self.length         = length
+        self.radius_e_beam  = radius_e_beam
+        self.temp_perp      = temp_perp
+        self.temp_long      = temp_long
+        self.magnetic_field = magnetic_field
+
+        self.offset_x       = offset_x
+        self.offset_px      = offset_px
+        self.offset_y       = offset_y
+        self.offset_py      = offset_py
+        self.offset_energy  = offset_energy
+        
+        self.magnetic_field_ratio = magnetic_field_ratio
+        self.space_charge_factor  = space_charge_factor
+        self.record_flag          =  record_flag
+        
+    def get_backtrack_element(self, _context=None, _buffer=None, _offset=None):
+        raise NotImplementedError
+
 class ThinSliceNotNeededError(Exception):
     pass