xtrack 0.41.1__tar.gz → 0.42.0__tar.gz

{xtrack-0.41.1/xtrack.egg-info → xtrack-0.42.0}/PKG-INFO

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

xtrack-0.42.0/xtrack/_version.py

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

{xtrack-0.41.1 → xtrack-0.42.0}/xtrack/beam_elements/elements.py

@@ -78,9 +78,6 @@ class Drift(BeamElement):
         _pkg_root.joinpath('beam_elements/elements_src/drift_elem.h'),
         ]
 
-    def make_slice(self, weight):
-        return Drift(length=self.length * weight)
-
     @staticmethod
     def add_slice(weight, container, thick_name, slice_name, _buffer=None):
         container[slice_name] = Drift(_buffer=_buffer)
@@ -666,7 +663,7 @@ class Multipole(BeamElement):
         if ksl is not None:
             nksl[: len(ksl)] = np.array(ksl)
 
-        if 'delta_teper' not in kwargs.keys():
+        if 'delta_taper' not in kwargs.keys():
             kwargs['delta_taper'] = 0.0
 
         order = n - 1
@@ -873,6 +870,27 @@ class CombinedFunctionMagnet(BeamElement):
         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=self_or_ref.length * weight,
+            num_multipole_kicks=self_or_ref.num_multipole_kicks,
+            order=self_or_ref.order,
+            _buffer=_buffer,
+        )
+        ref = container[slice_name]
+
+        ref.k0 = _get_expr(self_or_ref.k0)
+        ref.k1 = _get_expr(self_or_ref.k1)
+        ref.h = _get_expr(self_or_ref.h)
+
+        for ii in range(len(self_or_ref.knl)):
+            ref.knl[ii] = _get_expr(self_or_ref.knl[ii]) * weight
+
+        for ii in range(len(self_or_ref.ksl)):
+            ref.ksl[ii] = _get_expr(self_or_ref.ksl[ii]) * weight
+
     @staticmethod
     def delete_element_ref(ref):
         # Remove the array fields
@@ -890,6 +908,50 @@ class CombinedFunctionMagnet(BeamElement):
         # Remove the ref to the element itself
         _unregister_if_preset(ref)
 
+class Sextupole(BeamElement):
+    isthick = True
+    has_backtrack = True
+
+    _xofields={
+        'k2': xo.Float64,
+        'k2s': xo.Float64,
+        'length': xo.Float64,
+    }
+
+    _extra_c_sources = [
+        _pkg_root.joinpath('beam_elements/elements_src/drift.h'),
+        _pkg_root.joinpath('beam_elements/elements_src/sextupole.h'),
+    ]
+
+    @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(3), ksl=np.zeros(3),
+                                          _buffer=_buffer)
+        ref = container[slice_name]
+
+        ref.knl[0] = 0.
+        ref.knl[1] = 0.
+        ref.knl[2] = weight * (
+            _get_expr(self_or_ref.k2) * _get_expr(self_or_ref.length))
+
+        ref.ksl[0] = 0.
+        ref.ksl[1] = 0.
+        ref.ksl[2] = weight * (
+            _get_expr(self_or_ref.k2s) * _get_expr(self_or_ref.length))
+
+        ref.order = 2
+
+    @staticmethod
+    def delete_element_ref(ref):
+        # Remove the scalar fields
+        for field in ['k2', 'k2s', 'length']:
+            _unregister_if_preset(getattr(ref, field))
+
+        # Remove the ref to the element itself
+        _unregister_if_preset(ref)
+
 
 class Quadrupole(BeamElement):
     isthick = True
@@ -1004,6 +1066,25 @@ class Quadrupole(BeamElement):
         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=self_or_ref.length * weight,
+            num_multipole_kicks=self_or_ref.num_multipole_kicks,
+            order=self_or_ref.order,
+            _buffer=_buffer,
+        )
+        ref = container[slice_name]
+
+        ref.k1 = _get_expr(self_or_ref.k1)
+
+        for ii in range(len(self_or_ref.knl)):
+            ref.knl[ii] = _get_expr(self_or_ref.knl[ii]) * weight
+
+        for ii in range(len(self_or_ref.ksl)):
+            ref.ksl[ii] = _get_expr(self_or_ref.ksl[ii]) * weight
+
     @staticmethod
     def delete_element_ref(ref):
         # Remove the array fields
@@ -1021,6 +1102,53 @@ class Quadrupole(BeamElement):
         _unregister_if_preset(ref)
 
 
+class Solenoid(BeamElement):
+    isthick = True
+
+    _xofields = {
+        'length': xo.Float64,
+        'ks': xo.Float64,
+        'ksi': xo.Float64,
+    }
+
+    _extra_c_sources = [
+        _pkg_root.joinpath('beam_elements/elements_src/drift.h'),
+        _pkg_root.joinpath('beam_elements/elements_src/solenoid.h'),
+    ]
+
+    def __init__(self, length=0, ks=0, ksi=0, **kwargs):
+        """
+        Solenoid element.
+
+        Parameters
+        ----------
+        length : float
+            Length of the element in meters.
+        ks : float
+            Strength of the solenoid component in rad / m. Only to be specified
+            when the element is thin, i.e. when `length` == 0.
+        ksi : float
+            Integrated strength of the solenoid component in rad.
+        """
+
+        if '_xobject' in kwargs.keys() and kwargs['_xobject'] is not None:
+            self.xoinitialize(**kwargs)
+            return
+
+        if length == 0:
+            # Fail when trying to create a thin solenoid, as these are not
+            # tested yet
+            raise NotImplementedError('Thin solenoids are not implemented yet.')
+            # self.isthick = False
+
+        if ksi and length:
+            raise ValueError(
+                "The parameter `ksi` can only be specified when `length` == 0."
+            )
+
+        self.xoinitialize(length=length, ks=ks, ksi=ksi, **kwargs)
+
+
 class Bend(BeamElement):
     isthick = True
     has_backtrack = True
@@ -1160,6 +1288,27 @@ class Bend(BeamElement):
         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=self_or_ref.length * weight,
+            num_multipole_kicks=self_or_ref.num_multipole_kicks,
+            order=self_or_ref.order,
+            _buffer=_buffer,
+        )
+        ref = container[slice_name]
+
+        ref.k0 = _get_expr(self_or_ref.k0)
+        ref.h = _get_expr(self_or_ref.h)
+        ref.length = _get_expr(self_or_ref.length) * weight
+
+        for ii in range(len(self_or_ref.knl)):
+            ref.knl[ii] = _get_expr(self_or_ref.knl[ii]) * weight
+
+        for ii in range(len(self_or_ref.ksl)):
+            ref.ksl[ii] = _get_expr(self_or_ref.ksl[ii]) * weight
+
     @staticmethod
     def delete_element_ref(ref):
         # Remove the array fields

{xtrack-0.41.1 → xtrack-0.42.0}/xtrack/beam_elements/elements_src/multipolar_kick.h

@@ -27,12 +27,6 @@ void multipolar_kick(
     double dpx = knl[index] * inv_factorial;
     double dpy = ksl[index] * inv_factorial;
 
-    #ifdef XTRACK_MULTIPOLE_TAPER
-    double const delta_taper = LocalParticle_get_delta(part);
-    dpx = dpx * (1 + delta_taper);
-    dpy = dpy * (1 + delta_taper);
-    #endif
-
     double const x   = LocalParticle_get_x(part);
     double const y   = LocalParticle_get_y(part);
     double const chi = LocalParticle_get_chi(part);

xtrack-0.42.0/xtrack/beam_elements/elements_src/sextupole.h

@@ -0,0 +1,67 @@
+// copyright ############################### //
+// This file is part of the Xtrack Package.  //
+// Copyright (c) CERN, 2023.                 //
+// ######################################### //
+
+#ifndef XTRACK_SEXTUPOLE_H
+#define XTRACK_SEXTUPOLE_H
+
+/*gpufun*/
+void Sextupole_track_local_particle(
+        SextupoleData el,
+        LocalParticle* part0
+) {
+    double length = SextupoleData_get_length(el);
+
+    #ifdef XSUITE_BACKTRACK
+        length = -length;
+    #endif
+
+    double const k2 = SextupoleData_get_k2(el);
+    double const k2s = SextupoleData_get_k2s(el);
+
+    double const knl2 = k2 * length;
+    double const ksl2 = k2s * length;
+
+    //start_per_particle_block (part0->part)
+
+        // Drift
+        Drift_single_particle(part, length / 2.);
+
+        // Sextupolar kick
+        int64_t index = 2;
+        double const inv_factorial = 0.5; // 1 / factorial(2)
+        double dpx = knl2 * inv_factorial;
+        double dpy = ksl2 * inv_factorial;
+
+        double const x   = LocalParticle_get_x(part);
+        double const y   = LocalParticle_get_y(part);
+        double const chi = LocalParticle_get_chi(part);
+
+        while( index > 0 )
+        {
+            double const zre = dpx * x - dpy * y;
+            double const zim = dpx * y + dpy * x;
+
+            index -= 1;
+
+            dpx = zre;
+            dpy = zim;
+        }
+
+        dpx = -chi * dpx; // rad
+        dpy =  chi * dpy; // rad
+
+        LocalParticle_add_to_px(part, dpx);
+        LocalParticle_add_to_py(part, dpy);
+
+        // Drift
+        Drift_single_particle(part, length / 2.);
+
+
+    //end_per_particle_block
+
+
+}
+
+#endif // XTRACK_SEXTUPOLE_H

xtrack-0.42.0/xtrack/beam_elements/elements_src/solenoid.h

@@ -0,0 +1,151 @@
+// copyright ############################### //
+// This file is part of the Xtrack Package.  //
+// Copyright (c) CERN, 2023.                 //
+// ######################################### //
+
+#ifndef XTRACK_SOLENOID_H
+#define XTRACK_SOLENOID_H
+
+#define IS_ZERO(X) (fabs(X) < 1e-9)
+
+/*gpufun*/
+void Solenoid_thin_track_single_particle(LocalParticle*, double, double, double);
+
+/*gpufun*/
+void Solenoid_thick_track_single_particle(LocalParticle*, double, double);
+
+
+/*gpufun*/
+void Solenoid_track_local_particle(SolenoidData el, LocalParticle* part0) {
+    // Parameters
+    const double length = SolenoidData_get_length(el);
+    const double ks = SolenoidData_get_ks(el);
+    const double ksi = SolenoidData_get_ksi(el);
+
+    if (IS_ZERO(length)) {
+        //start_per_particle_block (part0->part)
+        Solenoid_thin_track_single_particle(part, length, ks, ksi);
+        //end_per_particle_block
+    }
+    else {
+        //start_per_particle_block (part0->part)
+        Solenoid_thick_track_single_particle(part, length, ks);
+        //end_per_particle_block
+    }
+}
+
+
+/*gpufun*/
+void Solenoid_thin_track_single_particle(
+    LocalParticle* part,
+    double length,
+    double ks,
+    double ksi
+) {
+    const double sk = ks / 2;  // todo?: flip sign to change beam direction
+    const double skl = ksi / 2;
+    const double beta0 = LocalParticle_get_beta0(part);
+
+    // Particle coordinates
+    const double x = LocalParticle_get_x(part);
+    const double px = LocalParticle_get_px(part);
+    const double y = LocalParticle_get_y(part);
+    const double py = LocalParticle_get_py(part);
+    const double t = LocalParticle_get_zeta(part) / beta0;
+    const double pt = LocalParticle_get_ptau(part);
+    const double delta = LocalParticle_get_delta(part);
+
+    // Useful quantities
+    const double psigf = pt / beta0;
+    const double betas = beta0;
+
+    const double onedp = 1 + delta;
+    const double fppsig = (1 + (betas * betas) * psigf) / onedp;
+
+    // Set up C, S, Q, R, Z
+    const double cosTh = cos(skl / onedp);
+    const double sinTh = sin(skl / onedp);
+    const double Q = -skl * sk / onedp;
+    const double Z = fppsig / (onedp * onedp) * skl;
+    const double R = Z * sk;
+
+    const double pxf = px + x * Q;
+    const double pyf = py + y * Q;
+    const double sigf = t * betas - 0.5 * (x * x + y * y) * R;
+
+    // Final angles after solenoid
+    const double pxf_ =  pxf * cosTh + pyf * sinTh;
+    const double pyf_ = -pxf * sinTh + pyf * cosTh;
+
+    // Calculate new coordinates
+    const double new_x = x  * cosTh  +  y  * sinTh;
+    const double new_px = pxf_;
+    const double new_y = -x  * sinTh  +  y  * cosTh;
+    const double new_py = pyf_;
+    const double new_zeta = sigf + (x * new_py - y * new_px) * Z;
+
+    LocalParticle_set_x(part, new_x);
+    LocalParticle_set_px(part, new_px);
+    LocalParticle_set_y(part, new_y);
+    LocalParticle_set_py(part, new_py);
+    LocalParticle_set_zeta(part, new_zeta);
+}
+
+
+/*gpufun*/
+void Solenoid_thick_track_single_particle(
+    LocalParticle* part,
+    double length,
+    double ks
+) {
+    const double sk = ks / 2;  // todo?: flip sign to change beam direction
+
+    if (IS_ZERO(sk)) {
+        Drift_single_particle(part, length);
+        return;
+    }
+
+    const double skl = sk * length;
+
+    // Particle coordinates
+    const double x = LocalParticle_get_x(part);
+    const double px = LocalParticle_get_px(part);
+    const double y = LocalParticle_get_y(part);
+    const double py = LocalParticle_get_py(part);
+    const double delta = LocalParticle_get_delta(part);
+    const double rvv = LocalParticle_get_rvv(part);
+
+    // set up constants
+    const double pk1 = px + sk * y;
+    const double pk2 = py - sk * x;
+    const double ptr2 = pk1 * pk1 + pk2 * pk2;
+    const double one_plus_delta = 1 + delta;
+    const double one_plus_delta_sq = one_plus_delta * one_plus_delta;
+    const double pz = sqrt(one_plus_delta_sq - ptr2);
+
+    // set up constants
+    const double cosTh = cos(skl / pz);
+    const double sinTh = sin(skl / pz);
+
+    const double si = sin(skl / pz) / sk;
+    const double rps[4] = {
+        cosTh * x + sinTh * y,
+        cosTh * px + sinTh * py,
+        cosTh * y - sinTh * x,
+        cosTh * py - sinTh * px
+    };
+    const double new_x = cosTh * rps[0] + si * rps[1];
+    const double new_px = cosTh * rps[1] - sk * sinTh * rps[0];
+    const double new_y = cosTh * rps[2] + si * rps[3];
+    const double new_py = cosTh * rps[3] - sk * sinTh * rps[2];
+    const double add_to_zeta = length * (1 - one_plus_delta / (pz * rvv));
+
+    LocalParticle_set_x(part, new_x);
+    LocalParticle_set_px(part, new_px);
+    LocalParticle_set_y(part, new_y);
+    LocalParticle_set_py(part, new_py);
+    LocalParticle_add_to_zeta(part, add_to_zeta);
+    LocalParticle_add_to_s(part, length);
+}
+
+#endif // XTRACK_SOLENOID_H