Merge branch 'release/0.25.16'

Author: szymonlopaciuk

xfields/config_tools/spacecharge_config_tools.py

@@ -125,7 +125,7 @@ def install_spacecharge_frozen(line=None, _buffer=None,
                                            exclude_types_starting_with='SpaceCh')
 
     line_sc_off.build_tracker()
-    tw_at_sc = line_sc_off.twiss(particle_ref=particle_ref, at_elements=sc_names, method='4d')
+    tw_at_sc = line_sc_off.twiss4d(particle_ref=particle_ref).rows[sc_names]
 
     # Configure lenses
     for ii, sc in enumerate(sc_elements):

xfields/ibs/_analytical.py

@@ -351,10 +351,10 @@ def coulomb_log(
         # and can be skewed by some very high peaks in the optics
         with warnings.catch_warnings():  # Catch and ignore the scipy.integrate.IntegrationWarning
             warnings.simplefilter("ignore", category=UserWarning)
-            _bx_bar = quad(_bxb, self._twiss.s[0], self._twiss.s[-1])[0] / self._twiss.circumference
-            _by_bar = quad(_byb, self._twiss.s[0], self._twiss.s[-1])[0] / self._twiss.circumference
-            _dx_bar = quad(_dxb, self._twiss.s[0], self._twiss.s[-1])[0] / self._twiss.circumference
-            _dy_bar = quad(_dyb, self._twiss.s[0], self._twiss.s[-1])[0] / self._twiss.circumference
+            _bx_bar = quad(_bxb, self._twiss.s[0], self._twiss.s[-1])[0] / self._twiss.line_length
+            _by_bar = quad(_byb, self._twiss.s[0], self._twiss.s[-1])[0] / self._twiss.line_length
+            _dx_bar = quad(_dxb, self._twiss.s[0], self._twiss.s[-1])[0] / self._twiss.line_length
+            _dy_bar = quad(_dyb, self._twiss.s[0], self._twiss.s[-1])[0] / self._twiss.line_length
         # ----------------------------------------------------------------------------------------------
         # Calculate transverse temperature as 2*P*X, i.e. assume the transverse energy is temperature/2
         # We need the total energy and the particle mass in GeV hence the 1e-9 below
@@ -373,7 +373,7 @@ def coulomb_log(
         if bunched is True:  # bunched beam
             volume = 8.0 * np.sqrt(np.pi**3) * sigma_x_cm * sigma_y_cm * sigma_t_cm
         else:  # coasting beam
-            volume = 4.0 * np.pi * sigma_x_cm * sigma_y_cm * 100 * self._twiss.circumference
+            volume = 4.0 * np.pi * sigma_x_cm * sigma_y_cm * 100 * self._twiss.line_length
         density = total_beam_intensity / volume
         debye_length = 743.4 * np.sqrt(TempeV / density) / abs(self._particle.q0)
         # ----------------------------------------------------------------------------------------------
@@ -610,9 +610,9 @@ def integrals(
         Sxp: ArrayLike = 3 * self._twiss.gamma0**2 * phix**2 * ax * (R3 - R2) / sqrt_term
         # ----------------------------------------------------------------------------------------------
         # These are the integrands of the integrals in Eq (30-32) in Nagaitsev paper
-        Ix_integrand = self._twiss.betx / (self._twiss.circumference * sigx * sigy) * (Sx + Sp * (self._twiss.dx**2 / self._twiss.betx**2 + phix**2) + Sxp)
-        Iy_integrand = self._twiss.bety / (self._twiss.circumference * sigx * sigy) * (R2 + R3 - 2 * R1)
-        Iz_integrand = Sp / (self._twiss.circumference * sigx * sigy)
+        Ix_integrand = self._twiss.betx / (self._twiss.line_length * sigx * sigy) * (Sx + Sp * (self._twiss.dx**2 / self._twiss.betx**2 + phix**2) + Sxp)
+        Iy_integrand = self._twiss.bety / (self._twiss.line_length * sigx * sigy) * (R2 + R3 - 2 * R1)
+        Iz_integrand = Sp / (self._twiss.line_length * sigx * sigy)
         # fmt: on
         # ----------------------------------------------------------------------------------------------
         # Integrating the integrands above accross the ring to get the desired results
@@ -739,7 +739,7 @@ class instead.
                 "Using 'bunched=False' in this formalism makes the approximation of bunch length = C/(2*pi). "
                 "Please use the Bjorken-Mtingwa formalism for a correct handling of Dy."
             )
-            bunch_length: float = self._twiss.circumference / (2 * np.pi)
+            bunch_length: float = self._twiss.line_length / (2 * np.pi)
         # ----------------------------------------------------------------------------------------------
         # Ensure we update the integrals have been computed beforehand
         _ = self.integrals(gemitt_x=gemitt_x, gemitt_y=gemitt_y, sigma_delta=sigma_delta)
@@ -869,7 +869,7 @@ def _Gamma(
                 * gemitt_x
                 * gemitt_y
                 * sigma_delta
-                * self._twiss.circumference
+                * self._twiss.line_length
             )
 
     def _a(self, gemitt_x: float, gemitt_y: float, sigma_delta: float) -> ArrayLike:
@@ -1666,9 +1666,9 @@ def calculate_integral_vectorized(func: Callable) -> ArrayLike:
         LOGGER.debug("Getting average growth rates over the lattice")
         with warnings.catch_warnings():  # Catch and ignore the scipy.integrate.IntegrationWarning
             warnings.simplefilter("ignore", category=UserWarning)
-            Kx: float = float(quad(_kx, self._twiss.s[0], self._twiss.s[-1])[0] / self._twiss.circumference)
-            Ky: float = float(quad(_ky, self._twiss.s[0], self._twiss.s[-1])[0] / self._twiss.circumference)
-            Kz: float = float(quad(_kz, self._twiss.s[0], self._twiss.s[-1])[0] / self._twiss.circumference)
+            Kx: float = float(quad(_kx, self._twiss.s[0], self._twiss.s[-1])[0] / self._twiss.line_length)
+            Ky: float = float(quad(_ky, self._twiss.s[0], self._twiss.s[-1])[0] / self._twiss.line_length)
+            Kz: float = float(quad(_kz, self._twiss.s[0], self._twiss.s[-1])[0] / self._twiss.line_length)
         emittance_rates = IBSEmittanceGrowthRates(Kx, Ky, Kz)
         # ----------------------------------------------------------------------------------------------
         # Important: the calculations of B&M yield emittance growth rates (this is what one gets in MAD-X

xfields/ibs/_equilibrium.py

@@ -432,7 +432,7 @@ def get_ibs_and_synrad_emittance_evolution(
     # Initialize values for the iterative process (first time step is revolution period)
     iterations: float = 0
     tolerance: float = np.inf
-    time_step: float = twiss.T_rev0
+    time_step: float = twiss.t_rev0
     # Structures for iterative results (time, IBS growth rates, computed emittances)
     time_deltas: list[float] = []  # stores the deltas (!), we do a cumsum at the end
     K_x: list[float] = []

xfields/ibs/_kicks.py

@@ -386,7 +386,7 @@ def compute_kick_coefficients(self, particles: xt.Particles, **kwargs) -> IBSKic
         # (the particles.delta in Xsuite), we multiply by beta0**2 to adapt
         LOGGER.debug("Computing simple kick coefficients")
         beta0 = self._twiss.beta0
-        revolution_frequency: float = 1 / self._twiss.T_rev0
+        revolution_frequency: float = 1 / self._twiss.t_rev0
         Kx = float(sigma_px_normalized * np.sqrt(2 * scaling_factor * Tx / revolution_frequency))
         Ky = float(sigma_py_normalized * np.sqrt(2 * scaling_factor * Ty / revolution_frequency))
         Kz = float(sigma_delta * np.sqrt(2 * scaling_factor * Tz / revolution_frequency) * beta0**2)
@@ -578,7 +578,7 @@ def compute_kinetic_coefficients(
         beta0: float = self._twiss.beta0
         gamma0: float = self._twiss.gamma0
         radius: float = self._twiss.particle_on_co.get_classical_particle_radius0()
-        circumference: float = self._twiss.circumference
+        circumference: float = self._twiss.line_length
         betx = self._twiss.betx
         bety = self._twiss.bety
         dx = self._twiss.dx
@@ -680,7 +680,7 @@ def track(self, particles: xt.Particles) -> None:
         nplike = particles._context.nplike_lib
         # ----------------------------------------------------------------------------------------------
         # Compute delta_t for the turn and the line density (rho(z) term in Eq (19) of reference)
-        dt: float = self._twiss.T_rev0
+        dt: float = self._twiss.t_rev0
         rho_z: ArrayLike = line_density(particles, self.num_slices)  # on context
         # ----------------------------------------------------------------------------------------------
         # TODO: Michalis wrote rho(z) in the paper but the way he had implemented it, it is actually