xtrack 0.83.5__tar.gz → 0.84.2__tar.gz

{xtrack-0.83.5/xtrack.egg-info → xtrack-0.84.2}/PKG-INFO

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

xtrack-0.84.2/xtrack/_version.py

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

{xtrack-0.83.5 → xtrack-0.84.2}/xtrack/beam_elements/apertures_src/limitpolygon.h

@@ -56,30 +56,30 @@ void LimitPolygon_track_local_particle(LimitPolygonData el,
 GPUKERN
 void LimitPolygon_impact_point_and_normal(
 		             LimitPolygonData el,
-                /*gpuglmem*/ const double* x_in,
-                /*gpuglmem*/ const double* y_in, 
-                /*gpuglmem*/ const double* z_in,
-                /*gpuglmem*/ const double* x_out,
-                /*gpuglmem*/ const double* y_out, 
-                /*gpuglmem*/ const double* z_out,
-                             const int64_t n_impacts,
-                /*gpuglmem*/       double* x_inters,
-                /*gpuglmem*/       double* y_inters, 
-                /*gpuglmem*/       double* z_inters,
-                /*gpuglmem*/       double* Nx_inters,
-                /*gpuglmem*/       double* Ny_inters,
-                /*gpuglmem*/       int64_t* i_found){ 
-			           
+                GPUGLMEM const double* x_in,
+                GPUGLMEM const double* y_in,
+                GPUGLMEM const double* z_in,
+                GPUGLMEM const double* x_out,
+                GPUGLMEM const double* y_out,
+                GPUGLMEM const double* z_out,
+                         const int64_t n_impacts,
+                GPUGLMEM double* x_inters,
+                GPUGLMEM double* y_inters,
+                GPUGLMEM double* z_inters,
+                GPUGLMEM double* Nx_inters,
+                GPUGLMEM double* Ny_inters,
+                GPUGLMEM int64_t* i_found){
+
     double const tol = 1e-13;
 
     int64_t N_edg = LimitPolygonData_len_x_vertices(el);
-    /*gpuglmem*/ const double* Vx = LimitPolygonData_getp1_x_vertices(el, 0);
-    /*gpuglmem*/ const double* Vy = LimitPolygonData_getp1_y_vertices(el, 0);
-    /*gpuglmem*/ const double* Nx = LimitPolygonData_getp1_x_normal(el, 0);
-    /*gpuglmem*/ const double* Ny = LimitPolygonData_getp1_y_normal(el, 0);
+    GPUGLMEM const double* Vx = LimitPolygonData_getp1_x_vertices(el, 0);
+    GPUGLMEM const double* Vy = LimitPolygonData_getp1_y_vertices(el, 0);
+    GPUGLMEM const double* Nx = LimitPolygonData_getp1_x_normal(el, 0);
+    GPUGLMEM const double* Ny = LimitPolygonData_getp1_y_normal(el, 0);
     double resc_fac = LimitPolygonData_get_resc_fac(el);
 
-    for (int64_t i_imp=0; i_imp<n_impacts; i_imp++){ //vectorize_over i_imp n_impacts
+    VECTORIZE_OVER(i_imp, n_impacts);
 
         double t_min_curr = 1.;
         int64_t i_found_curr = -1;
@@ -89,9 +89,8 @@ void LimitPolygon_impact_point_and_normal(
         double y_out_curr = y_out[i_imp];
 
         for (int64_t ii=0; ii<N_edg; ii++){
-
-	    double t_border;
-	    double t_ii;
+	        double t_border;
+	        double t_ii;
             double const den = ((y_out_curr-y_in_curr)*(Vx[ii+1]-Vx[ii])
 			    +(x_in_curr-x_out_curr)*(Vy[ii+1]-Vy[ii]));
             if (den == 0.){
@@ -99,23 +98,23 @@ void LimitPolygon_impact_point_and_normal(
                 // the case case overlapping the edge is not possible (this would not allow Pin inside and Pout outside - a point on the edge is condidered outside)
                 // the only case left is segment parallel to tue edge => no intersection
                 t_border = -2.;
-	    }
+	        }
             else{
                 t_border=((y_out_curr-y_in_curr)*(x_in_curr-Vx[ii])
 		         +(x_in_curr-x_out_curr)*(y_in_curr-Vy[ii]))/den;
-	    }
+	        }
 
             if (t_border>=0.-tol && t_border<=1.+tol){
                 t_ii = (Nx[ii]*(Vx[ii]-x_in_curr)
-		       +Ny[ii]*(Vy[ii]-y_in_curr)) 
-		       /(Nx[ii]*(x_out_curr-x_in_curr)
-	                 +Ny[ii]*(y_out_curr-y_in_curr));
+		            +Ny[ii]*(Vy[ii]-y_in_curr))
+		            /(Nx[ii]*(x_out_curr-x_in_curr)
+	                +Ny[ii]*(y_out_curr-y_in_curr));
                 if (t_ii>=0.-tol && t_ii<t_min_curr+tol){
-                    t_min_curr=t_ii;
+                    t_min_curr = t_ii;
                     i_found_curr = ii;
-		}
+		        }
             }
-	}
+	    }
 
         t_min_curr=resc_fac*t_min_curr;
         x_inters[i_imp]=t_min_curr*x_out_curr+(1.-t_min_curr)*x_in_curr;
@@ -125,10 +124,10 @@ void LimitPolygon_impact_point_and_normal(
         if (i_found_curr>=0){
             Nx_inters[i_imp] = Nx[i_found_curr];
             Ny_inters[i_imp] = Ny[i_found_curr];
-	}
+	    }
         i_found[i_imp] = i_found_curr;
-    } //end_vectorize
-    
+
+    END_VECTORIZE;
 }
 
 #endif

{xtrack-0.83.5 → xtrack-0.84.2}/xtrack/headers/track.h

@@ -22,6 +22,12 @@
     #define END_PER_PARTICLE_BLOCK \
             } \
         }
+
+    #define VECTORIZE_OVER(INDEX_NAME, COUNT) \
+        for (int INDEX_NAME = 0; INDEX_NAME < (COUNT); INDEX_NAME++) {
+
+    #define END_VECTORIZE \
+        }
 #endif  // XO_CONTEXT_CPU_SERIAL
 
 #ifdef XO_CONTEXT_CPU_OPENMP
@@ -42,6 +48,14 @@
                 } \
             } \
         }
+
+    #define VECTORIZE_OVER(INDEX_NAME, COUNT) \
+        _Pragma("omp parallel for") \
+        for (int INDEX_NAME = 0; INDEX_NAME < (COUNT); INDEX_NAME++) {
+
+    #define END_VECTORIZE \
+        }
+
 #endif  // XO_CONTEXT_CPU_OPENMP
 
 
@@ -53,6 +67,13 @@
 
     #define END_PER_PARTICLE_BLOCK \
             }
+
+    #define VECTORIZE_OVER(INDEX_NAME, COUNT) \
+        { \
+            int INDEX_NAME = blockDim.x * blockIdx.x + threadIdx.x;
+
+    #define END_VECTORIZE \
+        }
 #endif  // XO_CONTEXT_CUDA
 
 
@@ -64,6 +85,13 @@
 
     #define END_PER_PARTICLE_BLOCK \
             }
+
+    #define VECTORIZE_OVER(INDEX_NAME, COUNT) \
+        { \
+            int INDEX_NAME = get_global_id(0);
+
+    #define END_VECTORIZE \
+        }
 #endif  // XO_CONTEXT_CL
 
 

{xtrack-0.83.5 → xtrack-0.84.2}/xtrack/particles/rng_src/particles_rng.h

@@ -12,20 +12,19 @@ GPUKERN
 void Particles_initialize_rand_gen(ParticlesData particles,
     GPUGLMEM uint32_t* seeds, int n_init){
 
-    for (int ii=0; ii<n_init; ii++){//vectorize_over ii n_init
+    VECTORIZE_OVER(ii, n_init);
 
-    uint32_t s1, s2, s3, s4, s;
-    s = seeds[ii];
+        uint32_t s1, s2, s3, s4, s;
+        s = seeds[ii];
 
-    rng_set(&s1, &s2, &s3, &s4, s);
+        rng_set(&s1, &s2, &s3, &s4, s);
 
-    ParticlesData_set__rng_s1(particles, ii, s1);
-    ParticlesData_set__rng_s2(particles, ii, s2);
-    ParticlesData_set__rng_s3(particles, ii, s3);
-    ParticlesData_set__rng_s4(particles, ii, s4);
-
-     }//end_vectorize
+        ParticlesData_set__rng_s1(particles, ii, s1);
+        ParticlesData_set__rng_s2(particles, ii, s2);
+        ParticlesData_set__rng_s3(particles, ii, s3);
+        ParticlesData_set__rng_s4(particles, ii, s4);
 
+    END_VECTORIZE;
 }
 
 #endif /* XTRACK_PARTICLES_RNG_H */

{xtrack-0.83.5 → xtrack-0.84.2}/xtrack/twiss.py

@@ -8,6 +8,8 @@ import logging
 import io
 import json
 from functools import partial
+from typing import Literal
+
 import numpy as np
 from scipy.constants import c as clight
 from scipy.constants import hbar
@@ -3241,6 +3243,191 @@ class TwissTable(Table):
             **kwargs,
         )
 
+    def get_ibs_and_synrad_emittance_evolution(
+        self,
+        formalism: Literal["Nagaitsev", "Bjorken-Mtingwa", "B&M"],
+        total_beam_intensity: int,
+        gemitt_x: float | None = None,
+        nemitt_x: float | None = None,
+        gemitt_y: float | None = None,
+        nemitt_y: float | None = None,
+        gemitt_zeta: float | None = None,
+        nemitt_zeta: float | None = None,
+        overwrite_sigma_zeta: float | None = None,
+        overwrite_sigma_delta: float | None = None,
+        emittance_coupling_factor: float = 0,
+        emittance_constraint: Literal["coupling", "excitation"] | None = "coupling",
+        rtol: float = 1e-6,
+        tstep: float | None = None,
+        max_steps: float | None = None,
+        verbose: bool = True,
+        **kwargs,
+    ) -> Table:
+        """
+        Compute the evolution of emittances due to Synchrotron Radiation
+        and Intra-Beam Scattering until convergence to equilibrium values.
+        The equilibrium state is determined by an iterative process which
+        consists in computing the IBS growth rates and the emittance time
+        derivatives, then computing the emittances at the next time step,
+        potentially including the effect of transverse constraints, and
+        checking for convergence. The convergence criteria can be chosen
+        by the user.
+
+        Transverse emittances can be constrained to follow two scenarios:
+            - An emittance exchange originating from betatron coupling.
+            - A vertical emittance originating from an excitation.
+
+        The impact from the longitudinal impedance (e.g. bunch lengthening
+        or microwave instability) can be accounted for by specifying the RMS
+        bunch length and momentum spread.
+
+        Notes
+        -----
+            It is required that radiation has been configured in the line,
+            and that this `TwissTable` holds information on the equilibrium
+            state from Synchrotron Radiation. This means calling first
+            `line.configure_radiation(model="mean")` and then the `.twiss()`
+            method with `eneloss_and_damping=True`.
+
+        Warning
+        -------
+            If the user does not provide a starting emittance, the program
+            defaults to using the SR equilibrium value from this `TwissTable`,
+            which is a reasonable defaults for light sources. If a constraint
+            is provided via `emittance_constraint`  the starting emittances are
+            re-computed to respect that constraint (this is logged to the user).
+
+            If the user does provide starting emittances **and** a constraint, it
+            is up to the user to make sure these provided values are consistent
+            with the provided constraint!
+
+        Parameters
+        ----------
+        formalism : str
+            Which formalism to use for the computation of the IBS growth rates.
+            Can be ``Nagaitsev`` or ``Bjorken-Mtingwa`` (also accepts ``B&M``),
+            case-insensitively.
+        total_beam_intensity : int
+            The bunch intensity, in [particles per bunch].
+        gemitt_x : float, optional
+            Starting horizontal geometric emittance, in [m]. If neither this nor
+            the normalized one is provided, the SR equilibrium value from this
+            `TwissTable` is used.
+        nemitt_x : float, optional
+            Starting horizontal normalized emittance, in [m]. If neither this nor
+            the geometric one is provided, the SR equilibrium value from this
+            `TwissTable` is used.
+        gemitt_y : float, optional
+            Starting vertical geometric emittance, in [m]. If neither this nor
+            the normalized one is provided, the SR equilibrium value from this
+            `TwissTable` is used.
+        nemitt_y : float, optional
+            Starting vertical normalized emittance, in [m]. If neither this nor
+            the geometric one is provided, the SR equilibrium value from this
+            `TwissTable` is used.
+        gemitt_zeta : float, optional
+            Starting longitudinal geometric emittance, in [m]. If neither this
+            nor the normalized one is provided, the SR equilibrium value from
+            this `TwissTable` is used.
+        nemitt_zeta : float, optional
+            Starting longitudinal normalized emittance, in [m]. If neither this
+            nor the geometric one is provided, the SR equilibrium value from this
+            `TwissTable` is used.
+        emittance_coupling_factor : float, optional
+            The ratio of perturbed transverse emittances due to betatron coupling.
+            If a value is provided, it is taken into account for the evolution of
+            emittances and induces an emittance sharing between the two planes.
+            See the next parameter for possible scenarios and how this value is
+            used. Defaults to 0.
+        emittance_constraint : str, optional
+            If an accepted value is provided, enforces constraints on the transverse
+            emittances. Can be either "coupling" or "excitation", case-insensitively.
+            Defaults to "coupling".
+            - If `coupling`, vertical emittance is the result of linear coupling. In
+                this case both the vertical and horizontal emittances are altered and
+                determined based on the value of `emittance_coupling_factor` and the
+                damping partition numbers. If the horizontal and vertical partition
+                numbers are equal then the total transverse emittance is preserved.
+            - If `excitation`, vertical emittance is the result of an excitation
+                (e.g. from a feedback system) and is determined from the horizontal
+                emittance based on the value of `emittance_coupling_factor`. In this
+                case the total transverse emittance is NOT preserved.
+            Providing `None` allows one to study a scenario without constraint. Note
+            that as `emittance_coupling_factor` defaults to 0, the constraint has no
+            effect unless a non-zero factor is provided.
+        overwrite_sigma_zeta : float, optional
+            The RMS bunch length, in [m]. If provided, overwrites the one computed from
+            the longitudinal emittance and forces a recompute of the longitudinal
+            emittance. Defaults to `None`.
+        overwrite_sigma_delta : float, optional
+            The RMS momentum spread of the bunch. If provided, overwrites the one
+            computed from the longitudinal emittance and forces a recompute of the
+            longitudinal emittance. Defaults to `None`.
+        rtol : float, optional
+            Relative tolerance to determine when convergence is reached: if the relative
+            difference between the computed emittances and those at the previous step is
+            below `rtol`, then convergence is considered achieved. Defaults to 1e-6.
+        tstep : float, optional
+            Time step to use for each iteration, in [s]. If not provided, an
+            adaptive time step is computed based on the IBS growth rates and
+            the damping constants. Defaults to `None`.
+        max_steps : float, optional
+            The maximum number of iterations to perform before stopping the iterative
+            process. If not provided, the process continues until it reaches convergence
+            (according to the provided `rtol`). Defaults to `None`.
+        verbose : bool, optional
+            Whether to print out information on the current iteration step and estimated
+            convergence progress. Defaults to `True`.
+        **kwargs : dict
+            Keyword arguments are passed to the growth rates computation method of
+            the chosen IBS formalism implementation. See the formalism classes in
+            the ``xfields.ibs._analytical`` for more details.
+
+        Returns
+        -------
+        xtrack.Table
+            The convergence calculations results. The table contains the following
+            columns, as time-step by time-step quantities:
+                - time: time values at which quantities are computed, in [s].
+                - gemitt_x: horizontal geometric emittances, in [m].
+                - nemitt_x: horizontal normalized emittances, in [m].
+                - gemitt_y: vertical geometric emittances, in [m].
+                - nemitt_y: vertical normalized emittances, in [m].
+                - gemitt_zeta: longitudinal geometric emittances, in [m].
+                - nemitt_zeta: longitudinal normalized emittances, in [m].
+                - sigma_zeta: bunch lengths, in [m].
+                - sigma_delta: momentum spreads, in [-].
+                - Kx: horizontal IBS amplitude growth rates, in [s^-1].
+                - Ky: vertical IBS amplitude growth rates, in [s^-1].
+                - Kz: longitudinal IBS amplitude growth rates, in [s^-1].
+            The table also contains the following global quantities:
+                - damping_constants_s: radiation damping constants used, in [s].
+                - partition_numbers: damping partition numbers used.
+                - eq_gemitt_x: horizontal equilibrium geometric emittance from synchrotron radiation used, in [m].
+                - eq_gemitt_y: vertical equilibrium geometric emittance from synchrotron radiation used, in [m].
+                - eq_gemitt_zeta: longitudinal equilibrium geometric emittance from synchrotron radiation used, in [m].
+                - eq_sr_ibs_gemitt_x: final horizontal equilibrium geometric emittance converged to, in [m].
+                - eq_sr_ibs_nemitt_x: final horizontal equilibrium normalized emittance converged to, in [m].
+                - eq_sr_ibs_gemitt_y: final vertical equilibrium geometric emittance converged to, in [m].
+                - eq_sr_ibs_gemitt_y: final vertical equilibrium normalized emittance converged to, in [m].
+                - eq_sr_ibs_gemitt_zeta: final longitudinal equilibrium geometric emittance converged to, in [m].
+                - eq_sr_ibs_gemitt_zeta: final longitudinal equilibrium normalized emittance converged to, in [m].
+        """
+        try:
+            from xfields.ibs import get_ibs_and_synrad_emittance_evolution
+        except ImportError:
+            raise ImportError("Please install xfields to use this feature.")
+        return get_ibs_and_synrad_emittance_evolution(
+            self, formalism=formalism, total_beam_intensity=total_beam_intensity,
+            gemitt_x=gemitt_x, nemitt_x=nemitt_x, gemitt_y=gemitt_y, nemitt_y=nemitt_y,
+            gemitt_zeta=gemitt_zeta, nemitt_zeta=nemitt_zeta,
+            overwrite_sigma_zeta=overwrite_sigma_zeta,
+            overwrite_sigma_delta=overwrite_sigma_delta,
+            emittance_coupling_factor=emittance_coupling_factor,
+            emittance_constraint=emittance_constraint,
+            rtol=rtol, tstep=tstep, max_steps=max_steps, verbose=verbose, **kwargs,
+        )
+
     def get_R_matrix(self, start, end):
 
         assert self.values_at == 'entry', 'Not yet implemented for exit'

{xtrack-0.83.5 → xtrack-0.84.2/xtrack.egg-info}/PKG-INFO

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

xtrack-0.83.5/xtrack/_version.py

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