xcoll 0.4.0__py3-none-any.whl → 0.5.1__py3-none-any.whl

xcoll/beam_elements/{collimators_src → elements_src}/black_crystal.h

@@ -7,6 +7,22 @@
 #define XCOLL_ABSORBER_CRY_H
 
 
+/*gpufun*/
+int8_t BlackCrystalData_get_record_impacts(BlackCrystalData el){
+    return BlackCrystalData_get__record_interactions(el) % 2;
+}
+
+/*gpufun*/
+int8_t BlackCrystalData_get_record_exits(BlackCrystalData el){
+    return (BlackCrystalData_get__record_interactions(el) >> 1) % 2;
+}
+
+/*gpufun*/
+int8_t BlackCrystalData_get_record_scatterings(BlackCrystalData el){
+    return (BlackCrystalData_get__record_interactions(el) >> 2) % 2;
+}
+
+
 /*gpufun*/
 CrystalGeometry BlackCrystal_init_geometry(BlackCrystalData el, LocalParticle* part0, int8_t active){
     CrystalGeometry cg = (CrystalGeometry) malloc(sizeof(CrystalGeometry_));
@@ -35,10 +51,12 @@ CrystalGeometry BlackCrystal_init_geometry(BlackCrystalData el, LocalParticle* p
         // Impact table
         cg->record = BlackCrystalData_getp_internal_record(el, part0);
         cg->record_index = NULL;
-        cg->record_touches = 0;
+        cg->record_impacts = 0;
+        cg->record_exits = 0;
         if (cg->record){
             cg->record_index = InteractionRecordData_getp__index(cg->record);
-            cg->record_touches = BlackCrystalData_get_record_touches(el);
+            cg->record_impacts = BlackCrystalData_get_record_impacts(el);
+            cg->record_exits = BlackCrystalData_get_record_exits(el);
         }
         // Not needed, set to zero
         cg->miscut_angle = 0;

xcoll/beam_elements/elements_src/blowup.h

@@ -0,0 +1,42 @@
+// copyright ############################### #
+// This file is part of the Xcoll Package.   #
+// Copyright (c) CERN, 2024.                 #
+// ######################################### #
+
+#ifndef XCOLL_BLOWUP_H
+#define XCOLL_BLOWUP_H
+
+/*gpufun*/
+void BlowUp_track_local_particle(BlowUpData el, LocalParticle* part0){
+
+    int8_t plane          = BlowUpData_get__plane(el);
+    double max_kick       = BlowUpData_get__max_kick(el);
+    int8_t active         = BlowUpData_get__active(el);
+    int8_t individual     = BlowUpData_get_use_individual_kicks(el);
+    int64_t start_at_turn = BlowUpData_get_start_at_turn(el);
+    int64_t stop_at_turn  = BlowUpData_get_stop_at_turn(el);
+
+    //start_per_particle_block (part0->part)
+        if (active){
+            int64_t at_turn = LocalParticle_get_at_turn(part);
+            if (at_turn >= start_at_turn && at_turn < stop_at_turn){
+                double ran;
+                if (individual){
+                    ran = (2*RandomUniform_generate(part) - 1);
+                } else {
+                    ran = BlowUpData_get__rans(el, at_turn - start_at_turn);
+                }
+                double kick = max_kick * ran;
+                if (plane == 1){
+                    LocalParticle_add_to_px(part, kick);
+                } else if (plane == -1){
+                    LocalParticle_add_to_py(part, kick);
+                } else {
+                    LocalParticle_kill_particle(part, XC_ERR_INVALID_XOFIELD);
+                }
+            }
+        }
+    //end_per_particle_block
+}
+
+#endif /* XCOLL_BLOWUP_H */

xcoll/beam_elements/elements_src/emittance_monitor.h

@@ -0,0 +1,109 @@
+// copyright ############################### #
+// This file is part of the Xcoll Package.   #
+// Copyright (c) CERN, 2024.                 #
+// ######################################### #
+
+#ifndef XCOLL_EMITTANCE_MONITOR_H
+#define XCOLL_EMITTANCE_MONITOR_H
+
+#ifndef C_LIGHT
+#define C_LIGHT 299792458.0
+#endif
+
+/*gpufun*/
+void EmittanceMonitor_track_local_particle(EmittanceMonitorData el, LocalParticle* part0){
+    EmittanceMonitorData_set__cached(el, 0);
+    int64_t const start_at_turn = EmittanceMonitorData_get_start_at_turn(el);
+    int64_t const part_id_start = EmittanceMonitorData_get_part_id_start(el);
+    int64_t const part_id_end   = EmittanceMonitorData_get_part_id_end(el);
+    double const frev = EmittanceMonitorData_get_frev(el);
+    double const sampling_frequency = EmittanceMonitorData_get_sampling_frequency(el);
+
+    EmittanceMonitorRecord record = EmittanceMonitorData_getp_data(el);
+
+    int64_t max_slot = EmittanceMonitorRecord_len_count(record);
+
+    int const plane_selector = EmittanceMonitorData_get__plane_selector(el);
+    int const monitor_horizontal   =  plane_selector % 2;
+    int const monitor_vertical     = (plane_selector >> 1) % 2;
+    int const monitor_longitudinal = (plane_selector >> 2) % 2;
+
+    //start_per_particle_block(part0->part)
+        int64_t particle_id = LocalParticle_get_particle_id(part);
+        if (part_id_end < 0 || (part_id_start <= particle_id && particle_id < part_id_end)){
+
+            // zeta is the absolute path length deviation from the reference particle: zeta = (s - beta0*c*t)
+            // but without limits, i.e. it can exceed the circumference (for coasting beams)
+            // as the particle falls behind or overtakes the reference particle
+            double const zeta = LocalParticle_get_zeta(part);
+            double const beta0 = LocalParticle_get_beta0(part);
+            double const at_turn = LocalParticle_get_at_turn(part);
+
+            double x =0;
+            double px = 0;
+            double y = 0;
+            double py = 0;
+            double pzeta = 0;
+
+            // compute sample index
+            int64_t slot = round(sampling_frequency * ( (at_turn-start_at_turn)/frev - zeta/beta0/C_LIGHT ));
+
+            if (slot >= 0 && slot < max_slot){
+                /*gpuglmem*/ double *count = EmittanceMonitorRecord_getp1_count(record, slot); atomicAdd(count, 1);
+
+                if (monitor_horizontal){
+                    x  = LocalParticle_get_x(part);
+                    px = LocalParticle_get_px(part);
+                    /*gpuglmem*/ double *x_sum1     = EmittanceMonitorRecord_getp1_x_sum1(record, slot);     atomicAdd(x_sum1, x);
+                    /*gpuglmem*/ double *px_sum1    = EmittanceMonitorRecord_getp1_px_sum1(record, slot);    atomicAdd(px_sum1, px);
+                    /*gpuglmem*/ double *x_x_sum2   = EmittanceMonitorRecord_getp1_x_x_sum2(record, slot);   atomicAdd(x_x_sum2, x*x);
+                    /*gpuglmem*/ double *x_px_sum2  = EmittanceMonitorRecord_getp1_x_px_sum2(record, slot);  atomicAdd(x_px_sum2, x*px);
+                    /*gpuglmem*/ double *px_px_sum2 = EmittanceMonitorRecord_getp1_px_px_sum2(record, slot); atomicAdd(px_px_sum2, px*px);
+                }
+
+                if (monitor_vertical){
+                    y  = LocalParticle_get_y(part);
+                    py = LocalParticle_get_py(part);
+                    /*gpuglmem*/ double *y_sum1     = EmittanceMonitorRecord_getp1_y_sum1(record, slot);     atomicAdd(y_sum1, y);
+                    /*gpuglmem*/ double *py_sum1    = EmittanceMonitorRecord_getp1_py_sum1(record, slot);    atomicAdd(py_sum1, py);
+                    /*gpuglmem*/ double *y_y_sum2   = EmittanceMonitorRecord_getp1_y_y_sum2(record, slot);   atomicAdd(y_y_sum2, y*y);
+                    /*gpuglmem*/ double *y_py_sum2  = EmittanceMonitorRecord_getp1_y_py_sum2(record, slot);  atomicAdd(y_py_sum2, y*py);
+                    /*gpuglmem*/ double *py_py_sum2 = EmittanceMonitorRecord_getp1_py_py_sum2(record, slot); atomicAdd(py_py_sum2, py*py);
+                }
+
+                if (monitor_longitudinal){
+                    double const ptau = LocalParticle_get_ptau(part);
+                    pzeta = ptau/beta0;
+                    /*gpuglmem*/ double *zeta_sum1        = EmittanceMonitorRecord_getp1_zeta_sum1(record, slot);        atomicAdd(zeta_sum1, zeta);
+                    /*gpuglmem*/ double *pzeta_sum1       = EmittanceMonitorRecord_getp1_pzeta_sum1(record, slot);       atomicAdd(pzeta_sum1, pzeta);
+                    /*gpuglmem*/ double *zeta_zeta_sum2   = EmittanceMonitorRecord_getp1_zeta_zeta_sum2(record, slot);   atomicAdd(zeta_zeta_sum2, zeta*zeta);
+                    /*gpuglmem*/ double *zeta_pzeta_sum2  = EmittanceMonitorRecord_getp1_zeta_pzeta_sum2(record, slot);  atomicAdd(zeta_pzeta_sum2, zeta*pzeta);
+                    /*gpuglmem*/ double *pzeta_pzeta_sum2 = EmittanceMonitorRecord_getp1_pzeta_pzeta_sum2(record, slot); atomicAdd(pzeta_pzeta_sum2, pzeta*pzeta);
+                }
+
+                if (monitor_horizontal && monitor_vertical){
+                    /*gpuglmem*/ double *x_y_sum2   = EmittanceMonitorRecord_getp1_x_y_sum2(record, slot);   atomicAdd(x_y_sum2, x*y);
+                    /*gpuglmem*/ double *x_py_sum2  = EmittanceMonitorRecord_getp1_x_py_sum2(record, slot);  atomicAdd(x_py_sum2, x*py);
+                    /*gpuglmem*/ double *px_y_sum2  = EmittanceMonitorRecord_getp1_px_y_sum2(record, slot);  atomicAdd(px_y_sum2, px*y);
+                    /*gpuglmem*/ double *px_py_sum2 = EmittanceMonitorRecord_getp1_px_py_sum2(record, slot); atomicAdd(px_py_sum2, px*py);
+                }
+
+                if (monitor_horizontal && monitor_longitudinal){
+                    /*gpuglmem*/ double *x_zeta_sum2   = EmittanceMonitorRecord_getp1_x_zeta_sum2(record, slot);   atomicAdd(x_zeta_sum2, x*zeta);
+                    /*gpuglmem*/ double *x_pzeta_sum2  = EmittanceMonitorRecord_getp1_x_pzeta_sum2(record, slot);  atomicAdd(x_pzeta_sum2, x*pzeta);
+                    /*gpuglmem*/ double *px_zeta_sum2  = EmittanceMonitorRecord_getp1_px_zeta_sum2(record, slot);  atomicAdd(px_zeta_sum2, px*zeta);
+                    /*gpuglmem*/ double *px_pzeta_sum2 = EmittanceMonitorRecord_getp1_px_pzeta_sum2(record, slot); atomicAdd(px_pzeta_sum2, px*pzeta);
+                }
+
+                if (monitor_vertical && monitor_longitudinal){
+                    /*gpuglmem*/ double *y_zeta_sum2   = EmittanceMonitorRecord_getp1_y_zeta_sum2(record, slot);   atomicAdd(y_zeta_sum2, y*zeta);
+                    /*gpuglmem*/ double *y_pzeta_sum2  = EmittanceMonitorRecord_getp1_y_pzeta_sum2(record, slot);  atomicAdd(y_pzeta_sum2, y*pzeta);
+                    /*gpuglmem*/ double *py_zeta_sum2  = EmittanceMonitorRecord_getp1_py_zeta_sum2(record, slot);  atomicAdd(py_zeta_sum2, py*zeta);
+                    /*gpuglmem*/ double *py_pzeta_sum2 = EmittanceMonitorRecord_getp1_py_pzeta_sum2(record, slot); atomicAdd(py_pzeta_sum2, py*pzeta);
+                }
+            }
+        }
+	//end_per_particle_block
+}
+
+#endif /* XCOLL_EMITTANCE_MONITOR_H */

xcoll/beam_elements/{collimators_src → elements_src}/everest_block.h

@@ -9,6 +9,21 @@
 #include <stdio.h>
 
 
+/*gpufun*/
+int8_t EverestBlockData_get_record_impacts(EverestBlockData el){
+    return EverestBlockData_get__record_interactions(el) % 2;
+}
+
+/*gpufun*/
+int8_t EverestBlockData_get_record_exits(EverestBlockData el){
+    return (EverestBlockData_get__record_interactions(el) >> 1) % 2;
+}
+
+/*gpufun*/
+int8_t EverestBlockData_get_record_scatterings(EverestBlockData el){
+    return (EverestBlockData_get__record_interactions(el) >> 2) % 2;
+}
+
 /*gpufun*/
 void EverestBlock_set_material(EverestBlockData el){
     MaterialData material = EverestBlockData_getp__material(el);
@@ -38,8 +53,10 @@ EverestCollData EverestBlock_init(EverestBlockData el, LocalParticle* part0, int
         // Impact table
         coll->record = EverestBlockData_getp_internal_record(el, part0);
         coll->record_index = NULL;
+        coll->record_scatterings = 0;
         if (coll->record){
             coll->record_index = InteractionRecordData_getp__index(coll->record);
+            coll->record_scatterings = EverestBlockData_get_record_scatterings(el);
         }
     }
 
@@ -68,7 +85,8 @@ EverestData EverestBlock_init_data(LocalParticle* part, EverestCollData coll){
 /*gpufun*/
 void EverestBlock_track_local_particle(EverestBlockData el, LocalParticle* part0) {
     int8_t active = EverestBlockData_get__tracking(el);
-    double const length   = EverestBlockData_get_length(el);
+    active       *= EverestBlockData_get_active(el);
+    double const length = EverestBlockData_get_length(el);
 
     // Initialise collimator data
     // TODO: we want this to happen before tracking (instead of every turn), as a separate kernel
@@ -107,7 +125,6 @@ void EverestBlock_track_local_particle(EverestBlockData el, LocalParticle* part0
                 EverestData everest = EverestBlock_init_data(part, coll);
                 energy = jaw(everest, part, energy, length, 0);
                 free(everest);
-
                 LocalParticle_add_to_s(part, s_block);
 
                 LocalParticle_set_zeta(part, zeta_in);

xcoll/beam_elements/{collimators_src → elements_src}/everest_collimator.h

@@ -9,6 +9,21 @@
 #include <stdio.h>
 
 
+/*gpufun*/
+int8_t EverestCollimatorData_get_record_impacts(EverestCollimatorData el){
+    return EverestCollimatorData_get__record_interactions(el) % 2;
+}
+
+/*gpufun*/
+int8_t EverestCollimatorData_get_record_exits(EverestCollimatorData el){
+    return (EverestCollimatorData_get__record_interactions(el) >> 1) % 2;
+}
+
+/*gpufun*/
+int8_t EverestCollimatorData_get_record_scatterings(EverestCollimatorData el){
+    return (EverestCollimatorData_get__record_interactions(el) >> 2) % 2;
+}
+
 void EverestCollimator_set_material(EverestCollimatorData el){
     MaterialData material = EverestCollimatorData_getp__material(el);
     RandomRutherfordData rng = EverestCollimatorData_getp_rutherford_rng(el);
@@ -55,10 +70,12 @@ CollimatorGeometry EverestCollimator_init_geometry(EverestCollimatorData el, Loc
         // Impact table
         cg->record = EverestCollimatorData_getp_internal_record(el, part0);
         cg->record_index = NULL;
-        cg->record_touches = 0;
+        cg->record_impacts = 0;
+        cg->record_exits = 0;
         if (cg->record){
             cg->record_index = InteractionRecordData_getp__index(cg->record);
-            cg->record_touches = EverestCollimatorData_get_record_touches(el);
+            cg->record_impacts = EverestCollimatorData_get_record_impacts(el);
+            cg->record_exits = EverestCollimatorData_get_record_exits(el);
         }
     }
 
@@ -106,7 +123,6 @@ EverestCollData EverestCollimator_init(EverestCollimatorData el, LocalParticle*
         if (coll->record){
             coll->record_index = InteractionRecordData_getp__index(coll->record);
             coll->record_scatterings = EverestCollimatorData_get_record_scatterings(el);
-            coll->record_touches = EverestCollimatorData_get_record_touches(el);
         }
     }
 

xcoll/beam_elements/{collimators_src → elements_src}/everest_crystal.h

@@ -9,6 +9,22 @@
 #include <stdio.h>
 
 
+/*gpufun*/
+int8_t EverestCrystalData_get_record_impacts(EverestCrystalData el){
+    return EverestCrystalData_get__record_interactions(el) % 2;
+}
+
+/*gpufun*/
+int8_t EverestCrystalData_get_record_exits(EverestCrystalData el){
+    return (EverestCrystalData_get__record_interactions(el) >> 1) % 2;
+}
+
+/*gpufun*/
+int8_t EverestCrystalData_get_record_scatterings(EverestCrystalData el){
+    return (EverestCrystalData_get__record_interactions(el) >> 2) % 2;
+}
+
+
 void EverestCrystal_set_material(EverestCrystalData el){
     CrystalMaterialData material = EverestCrystalData_getp__material(el);
     RandomRutherfordData rng = EverestCrystalData_getp_rutherford_rng(el);
@@ -53,19 +69,23 @@ CrystalGeometry EverestCrystal_init_geometry(EverestCrystalData el, LocalParticl
         // Miscut centre
         cg->s_P = -R*sin(cg->miscut_angle);
         cg->x_P = R*cos(cg->miscut_angle);
-        // Mirror the crystal geometry
+        if (cg->side == 1 && R < 0){
+            // If R<0, a left-sided crystal bends towards the beam
+            cg->x_P = cg->x_P + cg->width;
+            cg->x_B = cg->x_B + cg->width;
+        } else if (cg->side == -1 && R > 0){
+            // If R>0, a right-sided crystal bends towards the beam
+            cg->x_P = cg->x_P - cg->width;
+            cg->x_B = cg->x_B - cg->width;
+        }
         if (cg->side == -1){
+            // Mirror the crystal geometry
             cg->bending_radius = -cg->bending_radius;
             cg->bending_angle  = -cg->bending_angle;
             cg->miscut_angle   = -cg->miscut_angle;
             cg->x_P            = -cg->x_P;
             cg->x_B            = -cg->x_B;
         }
-        if (R < 0){
-            // If R<0, a left-sided crystal bends towards the beam
-            cg->x_P = cg->x_P + cg->width;
-            cg->x_B = cg->x_B + cg->width;
-        }
         // From here on, crystal geometry parameters can always be treated as left-sided.
         // Note that the segments are not mirrored, which is fine as get_s_of_first_crossing_with_vlimit
         // is absolute (not in the jaw reference frame). It is only after a hit is registered, that we
@@ -80,10 +100,12 @@ CrystalGeometry EverestCrystal_init_geometry(EverestCrystalData el, LocalParticl
         // Impact table
         cg->record = EverestCrystalData_getp_internal_record(el, part0);
         cg->record_index = NULL;
-        cg->record_touches = 0;
+        cg->record_impacts = 0;
+        cg->record_exits = 0;
         if (cg->record){
             cg->record_index = InteractionRecordData_getp__index(cg->record);
-            cg->record_touches = EverestCrystalData_get_record_touches(el);
+            cg->record_impacts = EverestCrystalData_get_record_impacts(el);
+            cg->record_exits = EverestCrystalData_get_record_exits(el);
         }
     }
 
@@ -129,7 +151,6 @@ EverestCollData EverestCrystal_init(EverestCrystalData el, LocalParticle* part0,
         if (coll->record){
             coll->record_index = InteractionRecordData_getp__index(coll->record);
             coll->record_scatterings = EverestCrystalData_get_record_scatterings(el);
-            coll->record_touches = EverestCrystalData_get_record_touches(el);
         }
     }
     return coll;

xcoll/beam_elements/everest.py

@@ -6,7 +6,6 @@
 import numpy as np
 
 import xobjects as xo
-import xpart as xp
 import xtrack as xt
 
 from .base import BaseBlock, BaseCollimator, BaseCrystal, InvalidXcoll
@@ -42,7 +41,7 @@ class EverestBlock(BaseBlock):
     _depends_on = [BaseBlock, EverestEngine]
 
     _extra_c_sources = [
-        _pkg_root.joinpath('beam_elements','collimators_src','everest_block.h')
+        _pkg_root.joinpath('beam_elements','elements_src','everest_block.h')
     ]
 
     _kernels = {
@@ -106,7 +105,7 @@ class EverestCollimator(BaseCollimator):
     _depends_on = [BaseCollimator, EverestEngine]
 
     _extra_c_sources = [
-        _pkg_root.joinpath('beam_elements','collimators_src','everest_collimator.h')
+        _pkg_root.joinpath('beam_elements','elements_src','everest_collimator.h')
     ]
 
     _kernels = {
@@ -146,7 +145,7 @@ class EverestCollimator(BaseCollimator):
 
     def get_backtrack_element(self, _context=None, _buffer=None, _offset=None):
         return InvalidXcoll(length=-self.length, _context=_context,
-                                 _buffer=_buffer, _offset=_offset)
+                            _buffer=_buffer, _offset=_offset)
 
 
 
@@ -173,7 +172,7 @@ class EverestCrystal(BaseCrystal):
     _depends_on = [BaseCrystal, EverestEngine]
 
     _extra_c_sources = [
-        _pkg_root.joinpath('beam_elements','collimators_src','everest_crystal.h')
+        _pkg_root.joinpath('beam_elements','elements_src','everest_crystal.h')
     ]
 
     _kernels = {
@@ -240,6 +239,6 @@ class EverestCrystal(BaseCrystal):
 
     def get_backtrack_element(self, _context=None, _buffer=None, _offset=None):
         return InvalidXcoll(length=-self.length, _context=_context,
-                                 _buffer=_buffer, _offset=_offset)
+                            _buffer=_buffer, _offset=_offset)