xtrack 0.97.0__tar.gz → 0.97.1__tar.gz

{xtrack-0.97.0/xtrack.egg-info → xtrack-0.97.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: xtrack
-Version: 0.97.0
+Version: 0.97.1
 Summary: Tracking library for particle accelerators
 Author: G. Iadarola et al.
 License-Expression: Apache-2.0

xtrack-0.97.1/ducktrack/be_beamfields/BB6D.py

@@ -0,0 +1,160 @@
+# copyright ############################### #
+# This file is part of the Xtrack Package.  #
+# Copyright (c) CERN, 2021.                 #
+# ######################################### #
+
+from . import propagate_sigma_matrix as psm
+from . import boost as boost
+
+# import transverse_efields as tef
+
+from . import gaussian_fields as gf
+
+
+import numpy as np
+
+
+from scipy.constants import c as c_light
+
+
+def BB6D_track(x, px, y, py, sigma, delta, q0, p0, bb6ddata, mathlib):
+
+    # print('Input px',px)
+
+    q_part = bb6ddata.q_part
+    parboost = bb6ddata.parboost
+    Sigmas_0_star = bb6ddata.Sigmas_0_star
+    N_slices = bb6ddata.N_slices
+    N_part_per_slice = bb6ddata.N_part_per_slice
+    x_slices_star = bb6ddata.x_slices_star
+    y_slices_star = bb6ddata.y_slices_star
+    sigma_slices_star = bb6ddata.sigma_slices_star
+    min_sigma_diff = bb6ddata.min_sigma_diff
+    threshold_singular = bb6ddata.threshold_singular
+
+    # Change reference frame
+    x_subCO = x - bb6ddata.x_CO - bb6ddata.delta_x
+    px_subCO = px - bb6ddata.px_CO
+    y_subCO = y - bb6ddata.y_CO - bb6ddata.delta_y
+    py_subCO = py - bb6ddata.py_CO
+    sigma_subCO = sigma - bb6ddata.sigma_CO
+    delta_subCO = delta - bb6ddata.delta_CO
+
+    # Boost coordinates of the weak beam
+    x_star, px_star, y_star, py_star, sigma_star, delta_star = boost.boost(
+        x_subCO,
+        px_subCO,
+        y_subCO,
+        py_subCO,
+        sigma_subCO,
+        delta_subCO,
+        parboost,
+    )
+    # ~ x_star, px_star, y_star, py_star, sigma_star, delta_star =
+    #      (x, px, y, py, sigma, delta)
+    for i_slice in range(N_slices):
+        sigma_slice_star = sigma_slices_star[i_slice]
+        x_slice_star = x_slices_star[i_slice]
+        y_slice_star = y_slices_star[i_slice]
+
+        # Compute force scaling factor
+        Ksl = N_part_per_slice[i_slice] * q_part * q0 / (p0 * c_light)
+
+        # Identify the Collision Point (CP)
+        S = 0.5 * (sigma_star - sigma_slice_star)
+
+        # Get strong beam shape at the CP
+        (
+            Sig_11_hat_star,
+            Sig_33_hat_star,
+            costheta,
+            sintheta,
+            dS_Sig_11_hat_star,
+            dS_Sig_33_hat_star,
+            dS_costheta,
+            dS_sintheta,
+            extra_data,
+        ) = psm.propagate_Sigma_matrix(
+            Sigmas_0_star, S, threshold_singular=threshold_singular
+        )
+
+        # Evaluate transverse coordinates of the weake baem w.r.t.
+        # the strong beam centroid
+        x_bar_star = x_star + px_star * S - x_slice_star
+        y_bar_star = y_star + py_star * S - y_slice_star
+
+        # Move to the uncoupled reference frame
+        x_bar_hat_star = x_bar_star * costheta + y_bar_star * sintheta
+        y_bar_hat_star = -x_bar_star * sintheta + y_bar_star * costheta
+
+        # Compute derivatives of the transformation
+        dS_x_bar_hat_star = x_bar_star * dS_costheta + y_bar_star * dS_sintheta
+        dS_y_bar_hat_star = (
+            -x_bar_star * dS_sintheta + y_bar_star * dS_costheta
+        )
+
+        # Compute normalized field
+        # Ex, Ey, Gx, Gy = tef.get_Ex_Ey_Gx_Gy_gauss(
+        #                     x=x_bar_hat_star, y=y_bar_hat_star,
+        #                     sigma_x=np.sqrt(Sig_11_hat_star),
+        #                     sigma_y=np.sqrt(Sig_33_hat_star),
+        #                     min_sigma_diff = min_sigma_diff)
+
+        Ex, Ey, Gx, Gy = gf.get_Ex_Ey_Gx_Gy_gauss(
+            x=x_bar_hat_star,
+            y=y_bar_hat_star,
+            sigma_x=np.sqrt(Sig_11_hat_star),
+            sigma_y=np.sqrt(Sig_33_hat_star),
+            min_sigma_diff=min_sigma_diff,
+            skip_Gs=False,
+            mathlib=mathlib,
+        )
+
+        # Compute kicks
+        Fx_hat_star = Ksl * Ex
+        Fy_hat_star = Ksl * Ey
+        Gx_hat_star = Ksl * Gx
+        Gy_hat_star = Ksl * Gy
+
+        # Move kisks to coupled reference frame
+        Fx_star = Fx_hat_star * costheta - Fy_hat_star * sintheta
+        Fy_star = Fx_hat_star * sintheta + Fy_hat_star * costheta
+
+        # Compute longitudinal kick
+        Fz_star = 0.5 * (
+            Fx_hat_star * dS_x_bar_hat_star
+            + Fy_hat_star * dS_y_bar_hat_star
+            + Gx_hat_star * dS_Sig_11_hat_star
+            + Gy_hat_star * dS_Sig_33_hat_star
+        )
+
+        # Apply the kicks (Hirata's synchro-beam)
+        delta_star = (
+            delta_star
+            + Fz_star
+            + 0.5
+            * (
+                Fx_star * (px_star + 0.5 * Fx_star)
+                + Fy_star * (py_star + 0.5 * Fy_star)
+            )
+        )
+        x_star = x_star - S * Fx_star
+        px_star = px_star + Fx_star
+        y_star = y_star - S * Fy_star
+        py_star = py_star + Fy_star
+
+    # Inverse boost on the coordinates of the weak beam
+    x_ret, px_ret, y_ret, py_ret, sigma_ret, delta_ret = boost.inv_boost(
+        x_star, px_star, y_star, py_star, sigma_star, delta_star, parboost
+    )
+
+    # Go back to original reference frame and remove dipolar effect
+    x_out = x_ret + bb6ddata.x_CO + bb6ddata.delta_x - bb6ddata.Dx_sub
+    px_out = px_ret + bb6ddata.px_CO - bb6ddata.Dpx_sub
+    y_out = y_ret + bb6ddata.y_CO + bb6ddata.delta_y - bb6ddata.Dy_sub
+    py_out = py_ret + bb6ddata.py_CO - bb6ddata.Dpy_sub
+    sigma_out = sigma_ret + bb6ddata.sigma_CO - bb6ddata.Dsigma_sub
+    delta_out = delta_ret + bb6ddata.delta_CO - bb6ddata.Ddelta_sub
+
+    # print(x_ret, px_ret, y_ret, py_ret, sigma_ret, delta_ret)
+    return x_out, px_out, y_out, py_out, sigma_out, delta_out

xtrack-0.97.1/ducktrack/be_beamfields/BB6Ddata.py

@@ -0,0 +1,309 @@
+# copyright ############################### #
+# This file is part of the Xtrack Package.  #
+# Copyright (c) CERN, 2021.                 #
+# ######################################### #
+
+import numpy as np
+
+from . import boost
+
+
+class ParBoost(object):
+    # it is practically a struct
+    def __init__(self, phi, alpha):
+        self.sphi = np.sin(phi)
+        self.cphi = np.cos(phi)
+        self.tphi = np.tan(phi)
+        self.salpha = np.sin(alpha)
+        self.calpha = np.cos(alpha)
+
+    def tobuffer(self):
+        buf = [self.sphi, self.cphi, self.tphi, self.salpha, self.calpha]
+        return np.array(buf, dtype=np.float64)
+
+
+class Sigmas(object):
+    def __init__(
+        self,
+        Sig_11_0,
+        Sig_12_0,
+        Sig_13_0,
+        Sig_14_0,
+        Sig_22_0,
+        Sig_23_0,
+        Sig_24_0,
+        Sig_33_0,
+        Sig_34_0,
+        Sig_44_0,
+    ):
+
+        self.Sig_11_0 = Sig_11_0
+        self.Sig_12_0 = Sig_12_0
+        self.Sig_13_0 = Sig_13_0
+        self.Sig_14_0 = Sig_14_0
+        self.Sig_22_0 = Sig_22_0
+        self.Sig_23_0 = Sig_23_0
+        self.Sig_24_0 = Sig_24_0
+        self.Sig_33_0 = Sig_33_0
+        self.Sig_34_0 = Sig_34_0
+        self.Sig_44_0 = Sig_44_0
+
+    def tobuffer(self):
+        buf = [
+            self.Sig_11_0,
+            self.Sig_12_0,
+            self.Sig_13_0,
+            self.Sig_14_0,
+            self.Sig_22_0,
+            self.Sig_23_0,
+            self.Sig_24_0,
+            self.Sig_33_0,
+            self.Sig_34_0,
+            self.Sig_44_0,
+        ]
+        return np.array(buf, dtype=np.float64)
+
+
+def boost_sigmas(Sigma_0, cphi):
+    Sigma_0_boosted = Sigmas(
+        Sigma_0.Sig_11_0,
+        Sigma_0.Sig_12_0 / cphi,
+        Sigma_0.Sig_13_0,
+        Sigma_0.Sig_14_0 / cphi,
+        Sigma_0.Sig_22_0 / cphi / cphi,
+        Sigma_0.Sig_23_0 / cphi,
+        Sigma_0.Sig_24_0 / cphi / cphi,
+        Sigma_0.Sig_33_0,
+        Sigma_0.Sig_34_0 / cphi,
+        Sigma_0.Sig_44_0 / cphi / cphi,
+    )
+    return Sigma_0_boosted
+
+
+def int_to_float64arr(val):
+    temp = np.zeros(1, (np.float64, {"i64": ("i8", 0)}))
+    temp["i64"][0] = val
+    return temp
+
+
+class BB6D_Data(object):
+    def __init__(
+        self,
+        q_part,
+        parboost,
+        Sigmas_0_star,
+        N_slices,
+        N_part_per_slice,
+        x_slices_star,
+        y_slices_star,
+        sigma_slices_star,
+        min_sigma_diff,
+        threshold_singular,
+        delta_x,
+        delta_y,
+        x_CO,
+        px_CO,
+        y_CO,
+        py_CO,
+        sigma_CO,
+        delta_CO,
+        Dx_sub,
+        Dpx_sub,
+        Dy_sub,
+        Dpy_sub,
+        Dsigma_sub,
+        Ddelta_sub,
+        enabled,
+    ):
+
+        self.q_part = q_part
+        self.parboost = parboost
+        self.Sigmas_0_star = Sigmas_0_star
+        self.min_sigma_diff = min_sigma_diff
+        self.threshold_singular = threshold_singular
+        self.N_slices = N_slices
+        self.N_part_per_slice = N_part_per_slice
+        self.x_slices_star = x_slices_star
+        self.y_slices_star = y_slices_star
+        self.sigma_slices_star = sigma_slices_star
+
+        self.delta_x = delta_x
+        self.delta_y = delta_y
+        self.x_CO = x_CO
+        self.px_CO = px_CO
+        self.y_CO = y_CO
+        self.py_CO = py_CO
+        self.sigma_CO = sigma_CO
+        self.delta_CO = delta_CO
+        self.Dx_sub = Dx_sub
+        self.Dpx_sub = Dpx_sub
+        self.Dy_sub = Dy_sub
+        self.Dpy_sub = Dpy_sub
+        self.Dsigma_sub = Dsigma_sub
+        self.Ddelta_sub = Ddelta_sub
+
+        self.enabled = enabled
+
+    def tobuffer(self):
+
+        buffer_list = []
+        # Buffers corresponding to BB6D struct
+        buffer_list.append(np.array([self.q_part], dtype=np.float64))
+        buffer_list.append(self.parboost.tobuffer())
+        buffer_list.append(self.Sigmas_0_star.tobuffer())
+        buffer_list.append(np.array([self.min_sigma_diff], dtype=np.float64))
+        buffer_list.append(
+            np.array([self.threshold_singular], dtype=np.float64)
+        )
+        buffer_list.append(int_to_float64arr(self.N_slices))
+
+        buffer_list.append(np.array([self.delta_x], dtype=np.float64))
+        buffer_list.append(np.array([self.delta_y], dtype=np.float64))
+        buffer_list.append(np.array([self.x_CO], dtype=np.float64))
+        buffer_list.append(np.array([self.px_CO], dtype=np.float64))
+        buffer_list.append(np.array([self.y_CO], dtype=np.float64))
+        buffer_list.append(np.array([self.py_CO], dtype=np.float64))
+        buffer_list.append(np.array([self.sigma_CO], dtype=np.float64))
+        buffer_list.append(np.array([self.delta_CO], dtype=np.float64))
+        buffer_list.append(np.array([self.Dx_sub], dtype=np.float64))
+        buffer_list.append(np.array([self.Dpx_sub], dtype=np.float64))
+        buffer_list.append(np.array([self.Dy_sub], dtype=np.float64))
+        buffer_list.append(np.array([self.Dpy_sub], dtype=np.float64))
+        buffer_list.append(np.array([self.Dsigma_sub], dtype=np.float64))
+        buffer_list.append(np.array([self.Ddelta_sub], dtype=np.float64))
+        buffer_list.append(
+            int_to_float64arr({True: 1, False: 0}[self.enabled])
+        )
+
+        buffer_list.append(int_to_float64arr(3))  # offset to N_part_per_slice
+        # offset to x_slices_star
+        buffer_list.append(int_to_float64arr(2 + self.N_slices))
+        # offset to y_slices_star
+        buffer_list.append(int_to_float64arr(1 + 2 * self.N_slices))
+        # offset to sigma_slices_star
+        buffer_list.append(int_to_float64arr(0 + 3 * self.N_slices))
+
+        # Buffers corresponding to arrays
+        buffer_list.append(np.array(self.N_part_per_slice, dtype=np.float64))
+        buffer_list.append(np.array(self.x_slices_star, dtype=np.float64))
+        buffer_list.append(np.array(self.y_slices_star, dtype=np.float64))
+        buffer_list.append(np.array(self.sigma_slices_star, dtype=np.float64))
+
+        buf = np.concatenate(buffer_list)
+
+        return buf
+
+
+def BB6D_init(
+    q_part,
+    phi,
+    alpha,
+    delta_x,
+    delta_y,
+    N_part_per_slice,
+    z_slices,
+    Sig_11_0,
+    Sig_12_0,
+    Sig_13_0,
+    Sig_14_0,
+    Sig_22_0,
+    Sig_23_0,
+    Sig_24_0,
+    Sig_33_0,
+    Sig_34_0,
+    Sig_44_0,
+    x_CO,
+    px_CO,
+    y_CO,
+    py_CO,
+    sigma_CO,
+    delta_CO,
+    min_sigma_diff,
+    threshold_singular,
+    Dx_sub,
+    Dpx_sub,
+    Dy_sub,
+    Dpy_sub,
+    Dsigma_sub,
+    Ddelta_sub,
+    enabled,
+):
+
+    assert len(N_part_per_slice) == len(z_slices)
+
+    # Prepare data for Lorentz transformation
+    parboost = ParBoost(phi=phi, alpha=alpha)
+
+    # Prepare data with strong beam shape
+    Sigmas_0 = Sigmas(
+        Sig_11_0,
+        Sig_12_0,
+        Sig_13_0,
+        Sig_14_0,
+        Sig_22_0,
+        Sig_23_0,
+        Sig_24_0,
+        Sig_33_0,
+        Sig_34_0,
+        Sig_44_0,
+    )
+
+    # Boost strong beam shape
+    Sigmas_0_star = boost_sigmas(Sigmas_0, parboost.cphi)
+
+    # Sort according to z, head at the first position in the arrays
+    ind_sorted = np.argsort(z_slices)[::-1]
+    z_slices = np.take(z_slices, ind_sorted)
+    N_part_per_slice = np.take(N_part_per_slice, ind_sorted)
+
+    # By boosting the strong z and all zeros, I get the transverse coordinates
+    # of the strong beam in the ref system of the weak
+    boost_vect = np.vectorize(boost.boost, excluded="parboost")
+    (
+        x_slices_star,
+        px_slices_star,
+        y_slices_star,
+        py_slices_star,
+        sigma_slices_star,
+        delta_slices_star,
+    ) = boost_vect(
+        x=0 * z_slices,
+        px=0 * z_slices,
+        y=0 * z_slices,
+        py=0 * z_slices,
+        sigma=z_slices,
+        delta=0 * z_slices,
+        parboost=parboost,
+    )
+
+    N_slices = len(z_slices)
+
+    bb6d_data = BB6D_Data(
+        q_part,
+        parboost,
+        Sigmas_0_star,
+        N_slices,
+        N_part_per_slice,
+        x_slices_star,
+        y_slices_star,
+        sigma_slices_star,
+        min_sigma_diff,
+        threshold_singular,
+        delta_x,
+        delta_y,
+        x_CO,
+        px_CO,
+        y_CO,
+        py_CO,
+        sigma_CO,
+        delta_CO,
+        Dx_sub,
+        Dpx_sub,
+        Dy_sub,
+        Dpy_sub,
+        Dsigma_sub,
+        Ddelta_sub,
+        enabled,
+    )
+
+    return bb6d_data

xtrack-0.97.1/ducktrack/be_beamfields/__init__.py

@@ -0,0 +1,7 @@
+# copyright ############################### #
+# This file is part of the Xtrack Package.  #
+# Copyright (c) CERN, 2021.                 #
+# ######################################### #
+
+from .beambeam import BeamBeam4D, BeamBeam6D
+from .spacecharge import SCQGaussProfile