xtrack 0.49.0__tar.gz → 0.50.0__tar.gz

{xtrack-0.49.0/xtrack.egg-info → xtrack-0.50.0}/PKG-INFO

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

xtrack-0.50.0/xtrack/_version.py

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

{xtrack-0.49.0 → xtrack-0.50.0}/xtrack/beam_elements/elements.py

@@ -747,7 +747,7 @@ class SimpleThinQuadrupole(BeamElement):
     )
 
 
-class CombinedFunctionMagnet(BeamElement):
+class Bend(BeamElement):
     isthick = True
     has_backtrack = True
 
@@ -761,17 +761,19 @@ class CombinedFunctionMagnet(BeamElement):
         'num_multipole_kicks': xo.Int64,
         'order': xo.Int64,
         'inv_factorial_order': xo.Float64,
+        'model': xo.Int64,
     }
 
     _rename = {
         'order': '_order',
+        'model': '_model'
     }
 
     _extra_c_sources = [
         _pkg_root.joinpath('beam_elements/elements_src/drift.h'),
+        _pkg_root.joinpath('beam_elements/elements_src/track_thick_bend.h'),
         _pkg_root.joinpath('beam_elements/elements_src/track_thick_cfd.h'),
-        _pkg_root.joinpath('beam_elements/elements_src/multipolar_kick.h'),
-        _pkg_root.joinpath('beam_elements/elements_src/combinedfunctionmagnet.h'),
+        _pkg_root.joinpath('beam_elements/elements_src/bend.h'),
     ]
 
     def __init__(self, **kwargs):
@@ -809,6 +811,8 @@ class CombinedFunctionMagnet(BeamElement):
         if kwargs.get('length', 0.0) == 0.0 and not '_xobject' in kwargs:
             raise ValueError("A thick element must have a length.")
 
+        model = kwargs.pop('model', None)
+
         knl = kwargs.get('knl', np.array([]))
         ksl = kwargs.get('ksl', np.array([]))
         order_from_kl = max(len(knl), len(ksl)) - 1
@@ -822,6 +826,8 @@ class CombinedFunctionMagnet(BeamElement):
 
         self.xoinitialize(**kwargs)
 
+        if model is not None:
+            self.model = model
         self.order = order
 
     @property
@@ -833,6 +839,28 @@ class CombinedFunctionMagnet(BeamElement):
         self._order = value
         self.inv_factorial_order = 1.0 / factorial(value, exact=True)
 
+    @property
+    def model(self):
+        return {
+            0: 'adaptive',
+            1: 'full', # same as adaptive (for backward compatibility)
+            2: 'bend-kick-bend',
+            3: 'rot-kick-rot',
+            4: 'expanded'
+        }[self._model]
+
+    @model.setter
+    def model(self, value):
+        assert value in ['adaptive', 'full', 'bend-kick-bend',
+                            'rot-kick-rot', 'expanded']
+        self._model = {
+            'adaptive': 0,
+            'full': 1,
+            'bend-kick-bend': 2,
+            'rot-kick-rot': 3,
+            'expanded': 4
+        }[value]
+
     @property
     def hxl(self): return self.h * self.length
 
@@ -888,6 +916,7 @@ class CombinedFunctionMagnet(BeamElement):
         ref.k0 = _get_expr(self_or_ref.k0)
         ref.h = _get_expr(self_or_ref.h)
         ref.k1 = _get_expr(self_or_ref.k1)
+        ref.model = _get_expr(self_or_ref.model)
 
         for ii in range(5):
             ref.knl[ii] = _get_expr(self_or_ref.knl[ii]) * weight
@@ -978,21 +1007,11 @@ class Quadrupole(BeamElement):
     _xofields={
         'k1': xo.Float64,
         'length': xo.Float64,
-        'knl': xo.Float64[5],
-        'ksl': xo.Float64[5],
-        'num_multipole_kicks': xo.Int64,
-        'order': xo.Int64,
-        'inv_factorial_order': xo.Float64,
-    }
-
-    _rename = {
-        'order': '_order',
     }
 
     _extra_c_sources = [
         _pkg_root.joinpath('beam_elements/elements_src/drift.h'),
         _pkg_root.joinpath('beam_elements/elements_src/track_thick_cfd.h'),
-        _pkg_root.joinpath('beam_elements/elements_src/multipolar_kick.h'),
         _pkg_root.joinpath('beam_elements/elements_src/quadrupole.h'),
     ]
 
@@ -1007,15 +1026,6 @@ class Quadrupole(BeamElement):
             Strength of the quadrupole component in m^-2.
         length : float
             Length of the element in meters.
-        knl : array_like, optional
-            Integrated strength of the high-order normal multipolar components
-            (knl[0] and knl[1] should not be used).
-        ksl : array_like, optional
-            Integrated strength of the high-order skew multipolar components
-            (ksl[0] and ksl[1] should not be used).
-        num_multipole_kicks : int, optional
-            Number of multipole kicks used to model high order multipolar
-            components.
         """
 
         if '_xobject' in kwargs.keys() and kwargs['_xobject'] is not None:
@@ -1025,35 +1035,20 @@ class Quadrupole(BeamElement):
         if kwargs.get('length', 0.0) == 0.0 and not '_xobject' in kwargs:
             raise ValueError("A thick element must have a length.")
 
-        knl = kwargs.get('knl', np.array([]))
-        ksl = kwargs.get('ksl', np.array([]))
-        order_from_kl = max(len(knl), len(ksl)) - 1
-        order = kwargs.get('order', max(4, order_from_kl))
-
-        if order > 4:
-            raise NotImplementedError # Untested
-
-        kwargs['knl'] = np.pad(knl, (0, 5 - len(knl)), 'constant')
-        kwargs['ksl'] = np.pad(ksl, (0, 5 - len(ksl)), 'constant')
-
         self.xoinitialize(**kwargs)
 
-        self.order = order
-
-    @property
-    def order(self):
-        return self._order
-
-    @order.setter
-    def order(self, value):
-        self._order = value
-        self.inv_factorial_order = 1.0 / factorial(value, exact=True)
+    @classmethod
+    def from_dict(cls, dct, **kwargs):
+        if 'num_multipole_kicks' in dct:
+            assert dct['num_multipole_kicks'] == 0
+            dct.pop('num_multipole_kicks')
+            dct.pop('knl', None)
+            dct.pop('ksl', None)
+            dct.pop('order', None)
+            dct.pop('inv_factorial_order', None)
 
-    @property
-    def hxl(self): return self.h * self.length
+        return cls(**dct, **kwargs)
 
-    @property
-    def hyl(self): return 0.0
 
     @property
     def radiation_flag(self): return 0.0
@@ -1068,57 +1063,26 @@ class Quadrupole(BeamElement):
 
         ref.knl[0] = 0.
         ref.knl[1] = (_get_expr(self_or_ref.k1) * _get_expr(self_or_ref.length)
-                      + _get_expr(self_or_ref.knl[1])) * weight
+                        ) * weight
 
-        order = 1
-        for ii in range(2, 5):
-            ref.knl[ii] = _get_expr(self_or_ref.knl[ii]) * weight
-
-            if _nonzero(ref.knl[ii]):
-                order = max(order, ii)
-
-        for ii in range(5):
-            ref.ksl[ii] = _get_expr(self_or_ref.ksl[ii]) * weight
-
-            if _nonzero(self_or_ref.ksl[ii]):  # update in the same way for ksl
-                order = max(order, ii)
-
-        ref.hxl = 0
         ref.length = _get_expr(self_or_ref.length) * weight
-        ref.order = order
 
     @classmethod
     def add_thick_slice(cls, weight, container, name, slice_name, _buffer=None):
         self_or_ref = container[name]
         container[slice_name] = cls(
             length=999.,
-            order=4,
             _buffer=_buffer,
         )
         ref = container[slice_name]
 
         ref.length = _get_expr(self_or_ref.length) * weight
-        ref.num_multipole_kicks = _get_expr(self_or_ref.num_multipole_kicks)
-        ref.order = _get_expr(self_or_ref.order)
         ref.k1 = _get_expr(self_or_ref.k1)
 
-        for ii in range(5):
-            ref.knl[ii] = _get_expr(self_or_ref.knl[ii]) * weight
-
-        for ii in range(5):
-            ref.ksl[ii] = _get_expr(self_or_ref.ksl[ii]) * weight
-
     @staticmethod
     def delete_element_ref(ref):
-        # Remove the array fields
-        for field in ['knl', 'ksl']:
-            for ii in range(5):
-                _unregister_if_preset(getattr(ref, field)[ii])
-
         # Remove the scalar fields
-        for field in [
-            'k1', 'length', 'num_multipole_kicks', 'order', 'inv_factorial_order',
-        ]:
+        for field in ['k1', 'length']:
             _unregister_if_preset(getattr(ref, field))
 
         # Remove the ref to the element itself
@@ -1172,186 +1136,15 @@ class Solenoid(BeamElement):
         self.xoinitialize(length=length, ks=ks, ksi=ksi, **kwargs)
 
 
-class Bend(BeamElement):
-    isthick = True
-    has_backtrack = True
-
-    _xofields={
-        'k0': xo.Float64,
-        'h': xo.Float64,
-        'length': xo.Float64,
-        'knl': xo.Float64[5],
-        'ksl': xo.Float64[5],
-        'num_multipole_kicks': xo.Int64,
-        'order': xo.Int64,
-        'inv_factorial_order': xo.Float64,
-        'model': xo.Int64,
-    }
-
-    _rename = {
-        'order': '_order',
-        'model': '_model'
-    }
+class CombinedFunctionMagnet():
 
-    _extra_c_sources = [
-        _pkg_root.joinpath('beam_elements/elements_src/drift.h'),
-        _pkg_root.joinpath('beam_elements/elements_src/track_thick_cfd.h'),
-        _pkg_root.joinpath('beam_elements/elements_src/track_thick_bend.h'),
-        _pkg_root.joinpath('beam_elements/elements_src/multipolar_kick.h'),
-        _pkg_root.joinpath('beam_elements/elements_src/bend.h'),
-    ]
-
-    def __init__(self, **kwargs):
-
-        """
-        Bending magnet element.
-
-        Parameters
-        ----------
-        k0 : float
-            Strength of the dipole component in m^-1.
-        h : float
-            Curvature of the reference trajectory in m^-1.
-        length : float
-            Length of the element in m.
-        knl : array_like, optional
-            Integrated strength of the high-order normal multipolar components
-            (knl[0] and knl[1] should not be used).
-        ksl : array_like, optional
-            Integrated strength of the high-order skew multipolar components
-            (ksl[0] and ksl[1] should not be used).
-        model: str, optional
-            Model used for the computation. It can be 'expanded' or 'full'.
-            Default is 'expanded'.
-        num_multipole_kicks : int
-            Number of multipole kicks used to model high order multipolar
-            components.
-        """
-
-        if '_xobject' in kwargs.keys() and kwargs['_xobject'] is not None:
-            self.xoinitialize(**kwargs)
-            return
-
-        if kwargs.get('length', 0.0) == 0.0 and not '_xobject' in kwargs:
-            raise ValueError("A thick element must have a length.")
-
-        model = kwargs.pop('model', None)
-
-        knl = kwargs.get('knl', np.array([]))
-        ksl = kwargs.get('ksl', np.array([]))
-        order_from_kl = max(len(knl), len(ksl)) - 1
-        order = kwargs.get('order', max(order_from_kl, 4))
-
-        if order > 4:
-            raise NotImplementedError # Untested
-
-        kwargs['knl'] = np.pad(knl, (0, 5 - len(knl)), 'constant')
-        kwargs['ksl'] = np.pad(ksl, (0, 5 - len(ksl)), 'constant')
-
-        self.xoinitialize(**kwargs)
-
-        if model is not None:
-            self.model = model
-        self.order = order
-
-    @property
-    def model(self):
-        return {
-            0: 'expanded',
-            1: 'full'
-        }[self._model]
-
-    @model.setter
-    def model(self, value):
-        assert value in ['expanded', 'full']
-        self._model = {
-            'expanded': 0,
-            'full': 1
-        }[value]
-
-    @property
-    def order(self):
-        return self._order
-
-    @order.setter
-    def order(self, value):
-        self._order = value
-        self.inv_factorial_order = 1.0 / factorial(value, exact=True)
-
-    @property
-    def hxl(self): return self.h * self.length
-
-    @property
-    def hyl(self): return 0.0
-
-    @property
-    def radiation_flag(self): return 0.0
-
-    @staticmethod
-    def add_slice(weight, container, thick_name, slice_name, _buffer=None):
-        self_or_ref = container[thick_name]
-
-        container[slice_name] = Multipole(knl=np.zeros(5), ksl=np.zeros(5),
-                                          _buffer=_buffer)
-        ref = container[slice_name]
-
-        ref.knl[0] = (_get_expr(self_or_ref.k0) * _get_expr(self_or_ref.length)
-                      + _get_expr(self_or_ref.knl[0])) * weight
-        order = 0
-        for ii in range(1, 5):
-            ref.knl[ii] = _get_expr(self_or_ref.knl[ii]) * weight
-
-            if _nonzero(self_or_ref.knl[ii]):  # order is max ii where knl[ii] is expr or nonzero
-                order = ii
-
-        for ii in range(5):
-            ref.ksl[ii] = _get_expr(self_or_ref.ksl[ii]) * weight
-
-            if _nonzero(self_or_ref.ksl[ii]):  # update in the same way for ksl
-                order = max(order, ii)
-
-        ref.hxl = _get_expr(self_or_ref.h) * _get_expr(self_or_ref.length) * weight
-        ref.length = _get_expr(self_or_ref.length) * weight
-        ref.order = order
+    def __init__(self, *args, **kwargs):
+        raise TypeError('`CombinedFunctionMagnet` is supported anymore. '
+                        'Use `Bend` instead.')
 
     @classmethod
-    def add_thick_slice(cls, weight, container, name, slice_name, _buffer=None):
-        self_or_ref = container[name]
-        container[slice_name] = cls(
-            length=999.,
-            order=4,
-            _buffer=_buffer,
-        )
-        ref = container[slice_name]
-
-        ref.length = _get_expr(self_or_ref.length) * weight
-        ref.num_multipole_kicks = _get_expr(self_or_ref.num_multipole_kicks)
-        ref.order = _get_expr(self_or_ref.order)
-        ref.k0 = _get_expr(self_or_ref.k0)
-        ref.h = _get_expr(self_or_ref.h)
-
-        for ii in range(5): # For now we hardcode 4
-            ref.knl[ii] = _get_expr(self_or_ref.knl[ii]) * weight
-
-        for ii in range(5): # For now we hardcode 4
-            ref.ksl[ii] = _get_expr(self_or_ref.ksl[ii]) * weight
-
-    @staticmethod
-    def delete_element_ref(ref):
-        # Remove the array fields
-        for field in ['knl', 'ksl']:
-            for ii in range(5):
-                _unregister_if_preset(getattr(ref, field)[ii])
-
-        # Remove the scalar fields
-        for field in [
-            'k0', 'h', 'length', 'num_multipole_kicks', 'order',
-            'inv_factorial_order',
-        ]:
-            _unregister_if_preset(getattr(ref, field))
-
-        # Remove the ref to the element itself
-        _unregister_if_preset(ref[field])
+    def from_dict(cls, dct):
+        return Bend(**dct)
 
 
 class Fringe(BeamElement):

xtrack-0.50.0/xtrack/beam_elements/elements_src/bend.h

@@ -0,0 +1,250 @@
+// copyright ############################### //
+// This file is part of the Xtrack Package.  //
+// Copyright (c) CERN, 2023.                 //
+// ######################################### //
+
+#ifndef XTRACK_BEND_H
+#define XTRACK_BEND_H
+
+
+// model = 0: adaptive
+// model = 1: full (for backward compatibility)
+// model = 2: bend-kick-bend
+// model = 3: rot-kick-rot
+// model = 4: expanded
+
+/*gpufun*/
+void track_multipolar_kick_bend(
+    LocalParticle* part, int64_t order, double inv_factorial_order,
+    /*gpuglmem*/ const double* knl,
+    /*gpuglmem*/ const double* ksl,
+    double const factor_knl_ksl,
+    double kick_weight, double k0, double k1, double h, double length){
+
+    double const k1l = k1 * length * kick_weight;
+    double const k0l = k0 * length * kick_weight;
+
+    // dipole kick
+    double dpx = -k0l;
+    double dpy = 0;
+
+    // quadrupole kick
+    double const x = LocalParticle_get_x(part);
+    double const y = LocalParticle_get_y(part);
+    dpx += -k1l * x;
+    dpy +=  k1l * y;
+
+    // k0h correction can be computed from this term in the hamiltonian
+    // H = 1/2 h k0 x^2
+    // (see MAD 8 physics manual, eq. 5.15, and apply Hamilton's eq. dp/ds = -dH/dx)
+    double const k0l_mult = knl[0] * factor_knl_ksl * kick_weight;
+    dpx += -(k0l + k0l_mult) * h * x;
+
+    // k1h correction can be computed from this term in the hamiltonian
+    // H = 1/3 hk1 x^3 - 1/2 hk1 xy^2
+    // (see MAD 8 physics manual, eq. 5.15, and apply Hamilton's eq. dp/ds = -dH/dx)
+    double const k1l_mult = knl[1] * factor_knl_ksl * kick_weight;
+    dpx += h * (k1l + k1l_mult) * (-x * x + 0.5 * y * y);
+    dpy += h * (k1l + k1l_mult) * x * y;
+
+    LocalParticle_add_to_px(part, dpx);
+    LocalParticle_add_to_py(part, dpy);
+
+
+    // multipolar kick
+    int64_t index = order;
+    double inv_factorial = inv_factorial_order;
+
+    double dpx_mul = knl[index] * factor_knl_ksl * inv_factorial;
+    double dpy_mul = ksl[index] * factor_knl_ksl * inv_factorial;
+
+    double const chi = LocalParticle_get_chi(part);
+
+    while( index > 0 )
+    {
+        double const zre = dpx_mul * x - dpy_mul * y;
+        double const zim = dpx_mul * y + dpy_mul * x;
+
+        inv_factorial *= index;
+        index -= 1;
+
+        double this_knl = knl[index] * factor_knl_ksl;
+        double this_ksl = ksl[index] * factor_knl_ksl;
+
+        dpx_mul = this_knl * inv_factorial + zre;
+        dpy_mul = this_ksl * inv_factorial + zim;
+    }
+
+    dpx_mul = -chi * dpx_mul; // rad
+    dpy_mul =  chi * dpy_mul; // rad
+
+    LocalParticle_add_to_px(part, kick_weight * dpx_mul);
+    LocalParticle_add_to_py(part, kick_weight * dpy_mul);
+
+}
+
+#define N_KICKS_YOSHIDA 7
+
+
+/*gpufun*/
+void Bend_track_local_particle(
+        BendData el,
+        LocalParticle* part0
+) {
+    double length = BendData_get_length(el);
+    double factor_knl_ksl = 1;
+
+    #ifdef XSUITE_BACKTRACK
+        length = -length;
+        factor_knl_ksl = -1;
+    #endif
+
+    const double k0 = BendData_get_k0(el);
+    const double k1 = BendData_get_k1(el);
+    const double h = BendData_get_h(el);
+
+    int64_t num_multipole_kicks = BendData_get_num_multipole_kicks(el);
+    const int64_t order = BendData_get_order(el);
+    const double inv_factorial_order = BendData_get_inv_factorial_order(el);
+
+    const int64_t model = BendData_get_model(el);
+
+    /*gpuglmem*/ const double *knl = BendData_getp1_knl(el, 0);
+    /*gpuglmem*/ const double *ksl = BendData_getp1_ksl(el, 0);
+
+    if (model==0 || model==1 || model==2 || model==3){
+
+            int64_t num_slices;
+            if (num_multipole_kicks == 0) { // num_multipole_kicks needs to be determined
+
+                if (fabs(h) < 1e-8){
+                    num_multipole_kicks = 0; // straight magnet
+                }
+                else{
+                    double b_circum = 2 * 3.14159 / fabs(h);
+                    num_multipole_kicks = fabs(length) / b_circum / 0.5e-3; // 0.5 mrad per kick (on average)
+                }
+            }
+
+            if (num_multipole_kicks <= N_KICKS_YOSHIDA) {
+                num_slices = 1;
+            }
+            else{
+                num_slices = num_multipole_kicks / N_KICKS_YOSHIDA + 1;
+            }
+
+            const double slice_length = length / (num_slices);
+            const double kick_weight = 1. / num_slices;
+            const double d_yoshida[] =
+                         {3.922568052387799819591407413100e-01,
+                          5.100434119184584780271052295575e-01,
+                          -4.710533854097565531482416645304e-01,
+                          6.875316825251809316199569366290e-02};
+                        //  {0x1.91abc4988937bp-2, 0x1.052468fb75c74p-1, // same in hex
+                        //  -0x1.e25bd194051b9p-2, 0x1.199cec1241558p-4 };
+                        //  {1/8.0, 1/8.0, 1/8.0, 1/8.0}; // Uniform, for debugging
+            const double k_yoshida[] =
+                         {7.845136104775599639182814826199e-01,
+                          2.355732133593569921359289764951e-01,
+                          -1.177679984178870098432412305556e+00,
+                          1.315186320683906284756403692882e+00};
+                        //  {0x1.91abc4988937bp-1, 0x1.e2743579895b4p-3, // same in hex
+                        //  -0x1.2d7c6f7933b93p+0, 0x1.50b00cfb7be3ep+0 };
+                        //  {1/7.0, 1/7.0, 1/7.0, 1/7.0}; // Uniform, for debugging
+
+            // printf("num_slices = %ld\n", num_slices);
+            // printf("slice_length = %e\n", slice_length);
+            // printf("check = %d\n", check);
+
+            double k0_kick = 0;
+            double k0_drift = 0;
+            if (model ==0 || model==1 || model==3){
+                // Slice is short w.r.t. bending radius
+                k0_kick = k0;
+                k0_drift = 0;
+            }
+            else {
+                // method is 2
+                // Force bend-kick-bend
+                k0_kick = 0;
+                k0_drift = k0;
+            }
+
+            // printf("k0_kick = %e\n", k0_kick);
+
+            // Check if it can be handled without slicing
+            int no_slice_needed = 0;
+            if (k0_kick == 0 && k1 == 0){
+                int multip_present = 0;
+                for (int mm=0; mm<=order; mm++){
+                    if (knl[mm] != 0 || ksl[mm] != 0){
+                        multip_present = 1;
+                        break;
+                    }
+                }
+                if (!multip_present){
+                    no_slice_needed = 1;
+                }
+            }
+
+            if (no_slice_needed){
+                // printf("No slicing needed\n");
+                //start_per_particle_block (part0->part)
+                    track_thick_bend(part, length, k0_drift, h);
+                //end_per_particle_block
+            }
+            else{
+                for (int ii = 0; ii < num_slices; ii++) {
+                    //start_per_particle_block (part0->part)
+                        track_thick_bend(part, slice_length * d_yoshida[0], k0_drift, h);
+                        track_multipolar_kick_bend(
+                            part, order, inv_factorial_order, knl, ksl, factor_knl_ksl,
+                            kick_weight * k_yoshida[0], k0_kick, k1, h, length);
+                        track_thick_bend(part, slice_length * d_yoshida[1], k0_drift, h);
+                        track_multipolar_kick_bend(
+                            part, order, inv_factorial_order, knl, ksl, factor_knl_ksl,
+                            kick_weight * k_yoshida[1], k0_kick, k1, h, length);
+                        track_thick_bend(part, slice_length * d_yoshida[2], k0_drift, h);
+                        track_multipolar_kick_bend(
+                            part, order, inv_factorial_order, knl, ksl, factor_knl_ksl,
+                            kick_weight * k_yoshida[2], k0_kick, k1, h, length);
+                        track_thick_bend(part, slice_length * d_yoshida[3], k0_drift, h);
+                        track_multipolar_kick_bend(
+                            part, order, inv_factorial_order, knl, ksl, factor_knl_ksl,
+                            kick_weight * k_yoshida[3], k0_kick, k1, h, length);
+                        track_thick_bend(part, slice_length * d_yoshida[3], k0_drift, h);
+                        track_multipolar_kick_bend(
+                            part, order, inv_factorial_order, knl, ksl, factor_knl_ksl,
+                            kick_weight * k_yoshida[2], k0_kick, k1, h, length);
+                        track_thick_bend(part, slice_length * d_yoshida[2], k0_drift, h);
+                        track_multipolar_kick_bend(
+                            part, order, inv_factorial_order, knl, ksl, factor_knl_ksl,
+                            kick_weight * k_yoshida[1], k0_kick, k1, h, length);
+                        track_thick_bend(part, slice_length * d_yoshida[1], k0_drift, h);
+                        track_multipolar_kick_bend(
+                            part, order, inv_factorial_order, knl, ksl, factor_knl_ksl,
+                            kick_weight * k_yoshida[0], k0_kick, k1, h, length);
+                        track_thick_bend(part, slice_length * d_yoshida[0], k0_drift, h);
+                    //end_per_particle_block
+                }
+            }
+
+    }
+    if (model==4){
+        const double slice_length = length / (num_multipole_kicks + 1);
+        const double kick_weight = 1. / num_multipole_kicks;
+        //start_per_particle_block (part0->part)
+            track_thick_cfd(part, slice_length, k0, k1, h);
+
+            for (int ii = 0; ii < num_multipole_kicks; ii++) {
+                track_multipolar_kick_bend(
+                            part, order, inv_factorial_order, knl, ksl, factor_knl_ksl,
+                            kick_weight, 0, 0, 0, 0);
+                track_thick_cfd(part, slice_length, k0, k1, h);
+            }
+        //end_per_particle_block
+    }
+
+}
+
+#endif // XTRACK_TRUEBEND_H