xtrack 0.88.0__tar.gz → 0.88.2__tar.gz

{xtrack-0.88.0/xtrack.egg-info → xtrack-0.88.2}/PKG-INFO

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

{xtrack-0.88.0 → xtrack-0.88.2}/tests/test_magnet.py

@@ -992,7 +992,7 @@ def test_edge_full_model_with_dipole_component_and_angle(test_context):
         # The rotation is also the other way than in the underlying map :'(
         xt.DipoleEdge(model='full', k=3, fint=0.3, hgap=0.4),
         xt.MultipoleEdge(kn=[0, 4, 5], order=2),
-        xt.Wedge(angle=-0.2, k=3),
+        xt.Wedge(angle=-0.2, k=3, k1=4, quad_wedge_then_dip_wedge=1),
     ]
 
     p0 = xt.Particles(
@@ -1030,7 +1030,7 @@ def test_edge_full_model_with_dipole_component_and_angle_exit(test_context):
         fringe_integral=0.3, half_gap=0.4, k_order=2, _context=test_context
     )
     e_ref = [
-        xt.Wedge(angle=-0.2, k=3),
+        xt.Wedge(angle=-0.2, k=3, k1=4),
         xt.MultipoleEdge(kn=[0, 4, 5], is_exit=True, order=2),
         xt.DipoleEdge(model='full', k=-3, fint=0.3, hgap=0.4),
         xt.YRotation(angle=np.rad2deg(-0.2)),

xtrack-0.88.2/tests/test_quadrupole_fringe_ptc.py

@@ -0,0 +1,66 @@
+# Checks entrance fringe for very strong quadrupole against values of PTC
+
+import xtrack as xt
+import numpy as np
+from cpymad.madx import Madx
+
+def test_quadrupole_fringe_ptc():
+    b2 = 100
+    b1 = 0
+    length=1e-20
+
+    # Initial conditions
+    x0 = 0.07
+    px0 = 0.03
+    y0 = 0.08
+    py0 = 0.06
+    zeta0 = 0.04
+    delta0=0.1
+    beta0=0.1
+
+    p0 = xt.Particles(x=x0,px=px0,y=y0,py=py0,delta=delta0,zeta=zeta0,beta0=beta0)
+
+    ptau0 = float(p0.ptau)
+    tau0 = zeta0/beta0
+
+    # XSuite
+    quadrupole = xt.Bend(length=length, k0=b1, k1=b2,
+                         edge_entry_model='full', edge_exit_model='full')
+    line = xt.Line(elements=[ quadrupole])
+    line.discard_tracker()
+    line.build_tracker()
+    line.track(p0)
+
+    mat = line.compute_one_turn_matrix_finite_differences(p0)['R_matrix']
+    det = np.linalg.det(mat)
+
+    assert np.isclose(det, 1.0)
+
+    # PTC
+    madx_sequence = line.to_madx_sequence('quadrupole_fringes')
+
+    madx = Madx()
+    madx.beam(particle='proton', beta=beta0)
+    madx.input(madx_sequence)
+    madx.use('quadrupole_fringes')
+
+    madx.input(f"""
+               ptc_create_universe;
+               ptc_create_layout, exact=true;
+               ptc_setswitch, fringe=true;
+               ptc_start, x={x0}, px={px0}, y={y0}, py={py0}, t={tau0}, pt={ptau0};
+               ptc_track, icase=6, TURNS=1;
+               ptc_track_end;
+               ptc_end;
+               stop;
+               """
+               )
+
+    df = madx.table.tracksumm.dframe()
+
+    assert np.isclose(p0.x, df.x[-1])
+    assert np.isclose(p0.px, df.px[-1])
+    assert np.isclose(p0.y, df.y[-1])
+    assert np.isclose(p0.py, df.py[-1])
+    assert np.isclose(p0.ptau, df.pt[-1])
+    assert np.isclose(p0.zeta/p0.beta0, df.t[-1])

xtrack-0.88.2/tests/test_quadrupole_wedge.py

@@ -0,0 +1,94 @@
+import xtrack as xt
+import numpy as np
+from cpymad.madx import Madx
+
+
+def test_quadrupole_wedge():
+    """
+    Hardcoded test for quadrupole wedge with hard edge fringe.
+    """
+
+    angle = 0.1
+    b2 = 5
+    b1 = 0
+
+    quadrupole = xt.Bend(length=0, k0=b1, k1=b2, edge_entry_angle=angle,
+                         edge_entry_model='full')
+    line= xt.Line(elements=[quadrupole])
+
+    x=np.linspace(-1e-2, 1e-2, 5)
+    px=np.linspace(-5e-2, 5e-2, 5)
+    y=np.linspace(-2e-2, 2e-2, 5)
+    py=np.linspace(-3e-2, 3e-2, 5)
+
+    p0 = xt.Particles(x=x,px=px,y=y,py=py)
+
+    line.discard_tracker()
+    line.build_tracker()
+    line.track(p0)
+
+    x_expval = np.array([-0.0100055, -0.00500069, 0.,  0.00500069, 0.01000557])
+    px_expval = np.array([-5.00952476e-02, -2.50259834e-02, 1.38777878e-17, 2.49697042e-02, 4.98702638e-02])
+    y_expval = np.array([-0.01999435, -0.00999929, 0., 0.00999928, 0.01999424])
+    py_expval = np.array([-0.0301435, -0.01503677, 0., 0.01496143, 0.02984211])
+
+    assert np.allclose(p0.x, x_expval)
+    assert np.allclose(p0.px, px_expval)
+    assert np.allclose(p0.y, y_expval)
+    assert np.allclose(p0.py, py_expval)
+
+
+def test_quadrupole_wedge_ptc():
+    """
+    Test against PTC with MAD8_WEDGE=False.
+    Hardcoded values since the option is not available without recompiling PTC.
+    """
+
+    angle_in = 0.1
+    angle_out = 0.13
+    b2 = 100
+    b1 = 0
+    length=1e-20
+
+    x0 = 0.07
+    px0 = 0.03
+    y0 = 0.08
+    py0 = 0.06
+    zeta0 = 0.04
+    delta0=0.1
+    beta0=0.1
+
+    p0 = xt.Particles(x=x0,px=px0,y=y0,py=py0,delta=delta0,zeta=zeta0,beta0=beta0)
+
+    ptau0 = float(p0.ptau)
+    tau0 = zeta0/beta0
+
+    # XSuite
+    quadrupole = xt.Bend(length=length, k0=b1, k1=b2,
+                         edge_entry_angle=angle_in, edge_exit_angle=angle_out,
+                         edge_entry_model='full', edge_exit_model='full')
+    line = xt.Line(elements=[quadrupole])
+
+    line.discard_tracker()
+    line.build_tracker()
+    line.track(p0)
+
+    mat = line.compute_one_turn_matrix_finite_differences(p0)['R_matrix']
+    det = np.linalg.det(mat)
+
+    assert np.isclose(det, 1.0)
+
+    # # PTC values obtained with recompiled version of PTC, setting MAD8_WEDGE=False
+    x_ptc = 0.07043818253
+    px_ptc = 0.1313937438
+    y_ptc = 0.07993855538
+    py_ptc = -0.07321782159
+    tau_ptc = 0.4245507041
+    ptau_ptc = 0.01049449328
+
+    assert np.isclose(p0.x, x_ptc)
+    assert np.isclose(p0.px, px_ptc)
+    assert np.isclose(p0.y, y_ptc)
+    assert np.isclose(p0.py, py_ptc)
+    assert np.isclose(p0.zeta/p0.beta0, tau_ptc)
+    assert np.isclose(p0.ptau, ptau_ptc)

xtrack-0.88.2/xtrack/_version.py

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

{xtrack-0.88.0 → xtrack-0.88.2}/xtrack/beam_elements/elements.py

@@ -2314,6 +2314,8 @@ class Wedge(BeamElement):
     _xofields = {
         'angle': xo.Float64,
         'k': xo.Float64,
+        'k1': xo.Float64,
+        'quad_wedge_then_dip_wedge': xo.Int64,
     }
 
     _extra_c_sources = [

{xtrack-0.88.0 → xtrack-0.88.2}/xtrack/beam_elements/elements_src/track_magnet_edge.h

@@ -111,7 +111,10 @@ void track_magnet_edge_particles(
         // model changes!
 
         #define MAGNET_WEDGE(PART) \
-            if (should_rotate) Wedge_single_particle((PART), -face_angle, knorm[0])
+            if (should_rotate & (k_order >= 0)) Wedge_single_particle((PART), -face_angle, knorm[0])
+
+        #define MAGNET_QUAD_WEDGE(PART) \
+            if (should_rotate & (k_order >= 1)) Quad_wedge_single_particle((PART), -face_angle, knorm[1])
 
         if (is_exit == 0){ // entry
             START_PER_PARTICLE_BLOCK(part0, part);
@@ -120,12 +123,18 @@ void track_magnet_edge_particles(
                 if (model == 1){
                     MAGNET_MULTIPOLE_FRINGE(part);
                 }
+                if (model == 1){
+                    MAGNET_QUAD_WEDGE(part);
+                }
                 MAGNET_WEDGE(part);
             END_PER_PARTICLE_BLOCK;
         }
         else { // exit
             START_PER_PARTICLE_BLOCK(part0, part);
                 MAGNET_WEDGE(part);
+                if (model == 1){
+                    MAGNET_QUAD_WEDGE(part);
+                }
                 if (model == 1){
                     MAGNET_MULTIPOLE_FRINGE(part);
                 }
@@ -138,6 +147,7 @@ void track_magnet_edge_particles(
         #undef MAGNET_DIPOLE_FRINGE
         #undef MAGNET_MULTIPOLE_FRINGE
         #undef MAGNET_WEDGE
+        #undef MAGNET_QUAD_WEDGE
     }
     else if (model == 3) { // only ax ay cancellation (already done above)
         // do nothing
@@ -145,4 +155,4 @@ void track_magnet_edge_particles(
     // If model is not 0 or 1, do nothing
 }
 
-#endif // XTRACK_TRACK_MAGNET_EDGE_H
+#endif // XTRACK_TRACK_MAGNET_EDGE_H

{xtrack-0.88.0 → xtrack-0.88.2}/xtrack/beam_elements/elements_src/track_mult_fringe.h

@@ -41,8 +41,7 @@ void MultFringe_track_single_particle(
     const double t = LocalParticle_get_zeta(part) / beta0;
     const double pt = LocalParticle_get_ptau(part);
 
-    const double one_plus_delta = LocalParticle_get_delta(part) + 1.0;
-    const double pz = sqrt(POW2(one_plus_delta) - POW2(px) - POW2(py));
+    const double rpp = LocalParticle_get_rpp(part);
 
     double rx = 1;
     double ix = 0;
@@ -112,18 +111,18 @@ void MultFringe_track_single_particle(
 
     }
 
-    double a = 1 - fxx / pz;
-    double b = -fyx / pz;
-    double c = -fxy / pz;
-    double d = 1 - fyy / pz;
-    double det = 1 / (a * d - b * c);
+    double a = 1 - fxx * rpp;
+    double b = -fyx * rpp;
+    double c = -fxy * rpp;
+    double d = 1 - fyy * rpp;
+    double det = (a * d - b * c);
 
     double new_px = (d * px - b * py) / det;
     double new_py = (a * py - c * px) / det;
-    double delta_t = (1 / beta0 + pt) * (new_px * fx + new_py * fy) / POW3(pz);
+    double delta_t = (1 / beta0 + pt) * (new_px * fx + new_py * fy) * POW3(rpp);
 
-    LocalParticle_add_to_x(part, -fx / pz);
-    LocalParticle_add_to_y(part, -fy / pz);
+    LocalParticle_add_to_x(part, -fx * rpp);
+    LocalParticle_add_to_y(part, -fy * rpp);
     LocalParticle_set_px(part, new_px);
     LocalParticle_set_py(part, new_py);
     LocalParticle_set_zeta(part, (t + delta_t) * beta0);

{xtrack-0.88.0 → xtrack-0.88.2}/xtrack/beam_elements/elements_src/track_wedge.h

@@ -57,4 +57,30 @@ void Wedge_single_particle(
     LocalParticle_add_to_zeta(part, -delta_ell / rvv);
 }
 
-#endif // XTRACK_TRACK_WEDGE_H
+GPUFUN
+void Quad_wedge_single_particle(
+        LocalParticle* part,  // LocalParticle to track
+        const double theta,   // Angle of the wedge
+        const double k1       // Quadrupole strength
+) {
+    // Params
+    const double b2 = k1 * LocalParticle_get_chi(part);
+
+        // Particle coordinates
+    const double x = LocalParticle_get_x(part);
+    const double y = LocalParticle_get_y(part);
+    const double px = LocalParticle_get_px(part);
+    const double py = LocalParticle_get_py(part);
+
+    // Map
+    const double new_px = px - b2 * x*x * theta + b2 * y*y/2 * theta;
+    const double new_py = py + b2 * x*y * theta;
+
+    // Update particle coordinates
+    LocalParticle_set_px(part, new_px);
+    LocalParticle_set_py(part, new_py);
+}
+
+
+#endif // XTRACK_TRACK_WEDGE_H
+

{xtrack-0.88.0 → xtrack-0.88.2}/xtrack/beam_elements/elements_src/wedge.h

@@ -17,9 +17,20 @@ void Wedge_track_local_particle(
     // Parameters
     const double angle = WedgeData_get_angle(el);
     const double k = WedgeData_get_k(el);
+    const double k1 = WedgeData_get_k1(el);
+    const int64_t quad_wedge_then_dip_wedge = WedgeData_get_quad_wedge_then_dip_wedge(el);
 
     START_PER_PARTICLE_BLOCK(part0, part);
-        Wedge_single_particle(part, angle, k);
+        if (quad_wedge_then_dip_wedge == 0) {
+            // Wedge then quadrupole wedge
+            Wedge_single_particle(part, angle, k);
+            Quad_wedge_single_particle(part, angle, k1);
+        }
+        else if (quad_wedge_then_dip_wedge == 1) {
+            // Quadrupole wedge then dipole wedge
+            Quad_wedge_single_particle(part, angle, k1);
+            Wedge_single_particle(part, angle, k);
+        }
     END_PER_PARTICLE_BLOCK;
 }
 

{xtrack-0.88.0 → xtrack-0.88.2/xtrack.egg-info}/PKG-INFO

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

{xtrack-0.88.0 → xtrack-0.88.2}/xtrack.egg-info/SOURCES.txt

@@ -82,6 +82,8 @@ tests/test_ps_against_ptc.py
 tests/test_ps_multiturn_twiss.py
 tests/test_psb_chicane.py
 tests/test_pyht_interface.py
+tests/test_quadrupole_fringe_ptc.py
+tests/test_quadrupole_wedge.py
 tests/test_radial_steering.py
 tests/test_radiation.py
 tests/test_radiation_equilibrium_emittances.py

xtrack-0.88.0/xtrack/_version.py

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