xcoll 0.3.6__py3-none-any.whl → 0.5.0__py3-none-any.whl

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 = CollimatorImpactsData_getp__index(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
@@ -84,43 +102,54 @@ void EverestBlock_track_local_particle(EverestBlockData el, LocalParticle* part0
             int8_t is_valid = xcoll_check_particle_init(coll->rng, part);
 
             if (is_valid) {
-                EverestData everest     = EverestBlock_init_data(part, coll);
-                double const e0         = LocalParticle_get_energy0(part) / 1.e9;        // Reference energy in GeV
-                double const p0         = LocalParticle_get_p0c(part) / 1e9;            // Reference momentum in GeV
+                // Store s-location of start of block
+                double s_block = LocalParticle_get_s(part);
+                LocalParticle_set_s(part, 0);
+
+                // Store initial coordinates for updating later
+                double const e0         = LocalParticle_get_energy0(part);
+                double const p0         = LocalParticle_get_p0c(part);
+                double const ptau_in    = LocalParticle_get_ptau(part);
+                double const rvv_in     = LocalParticle_get_rvv(part);
+#ifdef XCOLL_USE_EXACT
+                double const xp_in      = LocalParticle_get_exact_xp(part);
+                double const yp_in      = LocalParticle_get_exact_yp(part);
+#else
+                double const xp_in      = LocalParticle_get_xp(part);
+                double const yp_in      = LocalParticle_get_yp(part);
+#endif
+                double const zeta_in    = LocalParticle_get_zeta(part);
                 double const mass_ratio = LocalParticle_get_charge_ratio(part) / LocalParticle_get_chi(part);   // m/m0
-                double energy = (LocalParticle_get_ptau(part)*p0 + e0) * mass_ratio;    // energy in GeV
-                int is_abs = 0;
-                double const rpp_in  = LocalParticle_get_rpp(part);
-                double const rvv_in  = LocalParticle_get_rvv(part);
-                double const px_in   = LocalParticle_get_px(part);
-                double const py_in   = LocalParticle_get_py(part);
-
-                double* result = jaw(everest, part, energy, length, 0);
-                energy = result[0];
-                if (result[1] == 1){ is_abs = 1; }
-                double s_out = result[2];
-                free(result);
-                free(everest);
+                double energy           = (p0*ptau_in + e0) * mass_ratio;
 
-                double ptau_out = (energy/mass_ratio - e0) / p0;
-                LocalParticle_update_ptau(part, ptau_out);
-                if (is_abs==0){
-                    double px  = LocalParticle_get_px(part);
-                    double py  = LocalParticle_get_py(part);
+                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);
+                // Survived particles need correcting:
+                if (LocalParticle_get_state(part)>0){
+                    // Update energy
+                    double ptau_out = (energy/mass_ratio - e0) / p0;
+                    LocalParticle_update_ptau(part, ptau_out);
+                    // Update zeta
+#ifdef XCOLL_USE_EXACT
+                    double xp  = LocalParticle_get_exact_xp(part);
+                    double yp  = LocalParticle_get_exact_yp(part);
+#else
+                    double xp  = LocalParticle_get_xp(part);
+                    double yp  = LocalParticle_get_yp(part);
+#endif
                     double rvv = LocalParticle_get_rvv(part);
-                    double rpp = LocalParticle_get_rpp(part);
                     // First we drift half the length with the old angles:
-                    LocalParticle_add_to_zeta(part, drift_zeta_single(rvv_in, px_in*rpp_in, py_in*rpp_in, length/2) );
+                    LocalParticle_add_to_zeta(part, drift_zeta_single(rvv_in, xp_in, yp_in, length/2) );
                     // then half the length with the new angles:
-                    LocalParticle_add_to_zeta(part, drift_zeta_single(rvv, px*rpp, py*rpp, length/2) );
-                } else {
-                    LocalParticle_set_s(part, s_out);
-                    LocalParticle_set_state(part, XC_LOST_ON_EVEREST_BLOCK);
+                    LocalParticle_add_to_zeta(part, drift_zeta_single(rvv, xp, yp, length/2) );
                 }
             }
         }
     //end_per_particle_block
-
     free(coll);
 }
 

xcoll/beam_elements/elements_src/everest_collimator.h

@@ -0,0 +1,237 @@
+// copyright ############################### #
+// This file is part of the Xcoll Package.   #
+// Copyright (c) CERN, 2024.                 #
+// ######################################### #
+
+#ifndef XCOLL_EVEREST_COLL_H
+#define XCOLL_EVEREST_COLL_H
+#include <math.h>
+#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);
+    RandomRutherford_set_by_xcoll_material(rng, (GeneralMaterialData) material);
+}
+
+
+/*gpufun*/
+CollimatorGeometry EverestCollimator_init_geometry(EverestCollimatorData el, LocalParticle* part0, int8_t active){
+    CollimatorGeometry cg = (CollimatorGeometry) malloc(sizeof(CollimatorGeometry_));
+    if (active){ // This is needed in order to avoid that the initialisation is called during a twiss!
+        // Jaw corners (with tilts)
+        cg->jaw_LU = EverestCollimatorData_get__jaw_LU(el);
+        cg->jaw_RU = EverestCollimatorData_get__jaw_RU(el);
+        // Get angles of jaws
+        cg->sin_zL = EverestCollimatorData_get__sin_zL(el);
+        cg->cos_zL = EverestCollimatorData_get__cos_zL(el);
+        cg->sin_zR = EverestCollimatorData_get__sin_zR(el);
+        cg->cos_zR = EverestCollimatorData_get__cos_zR(el);
+        cg->sin_zDiff = EverestCollimatorData_get__sin_zDiff(el);
+        cg->cos_zDiff = EverestCollimatorData_get__cos_zDiff(el);
+        cg->jaws_parallel = EverestCollimatorData_get__jaws_parallel(el);
+        // Tilts
+        cg->sin_yL = EverestCollimatorData_get__sin_yL(el);
+        cg->cos_yL = EverestCollimatorData_get__cos_yL(el);
+        cg->sin_yR = EverestCollimatorData_get__sin_yR(el);
+        cg->cos_yR = EverestCollimatorData_get__cos_yR(el);
+        // Length and segments
+        cg->length = EverestCollimatorData_get_length(el);
+        cg->side   = EverestCollimatorData_get__side(el);
+        double s_U, s_D, x_D;
+        if (cg->side != -1){
+            s_U = cg->length/2 * (1-cg->cos_yL);
+            s_D = cg->length/2 * (1+cg->cos_yL);
+            x_D = EverestCollimatorData_get__jaw_LD(el);
+            cg->segments_L = create_jaw(s_U, cg->jaw_LU, s_D, x_D, cg->sin_yL/cg->cos_yL, 1);
+        }
+        if (cg->side != 1){
+            s_U = cg->length/2 * (1-cg->cos_yR);
+            s_D = cg->length/2 * (1+cg->cos_yR);
+            x_D = EverestCollimatorData_get__jaw_RD(el);
+            cg->segments_R = create_jaw(s_U, cg->jaw_RU, s_D, x_D, cg->sin_yR/cg->cos_yR, -1);
+        }
+        // Impact table
+        cg->record = EverestCollimatorData_getp_internal_record(el, part0);
+        cg->record_index = NULL;
+        cg->record_impacts = 0;
+        cg->record_exits = 0;
+        if (cg->record){
+            cg->record_index = InteractionRecordData_getp__index(cg->record);
+            cg->record_impacts = EverestCollimatorData_get_record_impacts(el);
+            cg->record_exits = EverestCollimatorData_get_record_exits(el);
+        }
+    }
+
+    return cg;
+}
+
+/*gpufun*/
+void EverestCollimator_free(CollimatorGeometry restrict cg, int8_t active){
+    if (active){
+        if (cg->side != -1){
+            destroy_jaw(cg->segments_L);
+        }
+        if (cg->side != 1){
+            destroy_jaw(cg->segments_R);
+        }
+    }
+    free(cg);
+}
+
+
+// TODO: it would be great if we could set EverestData as an xofield, because then we could
+// run this function at creation of the collimator instead of every turn
+// Hmmmm this should be called whenever we change an xofield
+/*gpufun*/
+EverestCollData EverestCollimator_init(EverestCollimatorData el, LocalParticle* part0, int8_t active){
+    EverestCollData coll = (EverestCollData) malloc(sizeof(EverestCollData_));
+    if (active){ // This is needed in order to avoid that the initialisation is called during a twiss!
+        // Random generator and material
+        coll->rng = EverestCollimatorData_getp_rutherford_rng(el);
+        MaterialData material = EverestCollimatorData_getp__material(el);
+        coll->exenergy = MaterialData_get_excitation_energy(material)*1.0e3; // MeV
+        coll->rho      = MaterialData_get_density(material);
+        coll->anuc     = MaterialData_get_A(material);
+        coll->zatom    = MaterialData_get_Z(material);
+        coll->bnref    = MaterialData_get_nuclear_elastic_slope(material);
+        coll->radl     = MaterialData_get_radiation_length(material);
+        coll->csref[0] = MaterialData_get_cross_section(material, 0);
+        coll->csref[1] = MaterialData_get_cross_section(material, 1);
+        coll->csref[5] = MaterialData_get_cross_section(material, 5);
+        coll->only_mcs = MaterialData_get__only_mcs(material);
+        // Impact table:  need it here to record interactions
+        coll->record = EverestCollimatorData_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 = EverestCollimatorData_get_record_scatterings(el);
+        }
+    }
+
+    return coll;
+}
+
+
+/*gpufun*/
+EverestData EverestCollimator_init_data(LocalParticle* part, EverestCollData coll){
+    EverestData everest = (EverestData) malloc(sizeof(EverestData_));
+    everest->coll = coll;
+    everest->rescale_scattering = 1;
+#ifndef XCOLL_REFINE_ENERGY
+    // Preinitialise scattering parameters
+    double charge_ratio = LocalParticle_get_charge_ratio(part);
+    double mass_ratio = charge_ratio / LocalParticle_get_chi(part);
+    double energy = ( LocalParticle_get_ptau(part) + 1 / LocalParticle_get_beta0(part)
+                     ) * mass_ratio * LocalParticle_get_p0c(part) / 1e9; // energy in GeV
+    energy = LocalParticle_get_energy0(part) / 1e9;
+    calculate_scattering(everest, energy);
+    calculate_ionisation_properties(everest, energy);
+#endif
+    return everest;
+}
+
+
+/*gpufun*/
+void EverestCollimator_track_local_particle(EverestCollimatorData el, LocalParticle* part0) {
+    int8_t active = EverestCollimatorData_get_active(el);
+    active       *= EverestCollimatorData_get__tracking(el);
+    double const length = EverestCollimatorData_get_length(el);
+
+    // Initialise collimator data
+    // TODO: we want this to happen before tracking (instead of every turn), as a separate kernel
+    EverestCollData coll  = EverestCollimator_init(el, part0, active);
+    CollimatorGeometry cg = EverestCollimator_init_geometry(el, part0, active);
+
+    //start_per_particle_block (part0->part)
+        if (!active){
+            // Drift full length
+            Drift_single_particle(part, length);
+
+        } else {
+            // Check collimator initialisation
+            int8_t is_valid = xcoll_check_particle_init(coll->rng, part);
+
+            if (is_valid) {
+                // Store s-location of start of collimator
+                double const s_coll = LocalParticle_get_s(part);
+                LocalParticle_set_s(part, 0);
+
+                // Store initial coordinates for updating later
+                double const e0         = LocalParticle_get_energy0(part);
+                double const p0         = LocalParticle_get_p0c(part);
+                double const ptau_in    = LocalParticle_get_ptau(part);
+                double const rvv_in     = LocalParticle_get_rvv(part);
+#ifdef XCOLL_USE_EXACT
+                double const xp_in      = LocalParticle_get_exact_xp(part);
+                double const yp_in      = LocalParticle_get_exact_yp(part);
+#else
+                double const xp_in      = LocalParticle_get_xp(part);
+                double const yp_in      = LocalParticle_get_yp(part);
+#endif
+                double const zeta_in    = LocalParticle_get_zeta(part);
+                double const mass_ratio = LocalParticle_get_charge_ratio(part) / LocalParticle_get_chi(part);   // m/m0
+                double energy           = (p0*ptau_in + e0) * mass_ratio;
+
+                // Check if hit on jaws
+                int8_t is_hit = hit_jaws_check_and_transform(part, cg);
+
+                if (is_hit != 0) {
+                    // Hit one of the jaws, so scatter
+                    double remaining_length = length - LocalParticle_get_s(part);
+                    // Scatter
+                    EverestData everest = EverestCollimator_init_data(part, coll);
+                    energy = jaw(everest, part, energy, remaining_length, 1);
+                    free(everest);
+                }
+
+                // Transform back to the lab frame
+                hit_jaws_transform_back(is_hit, part, cg);
+                LocalParticle_add_to_s(part, s_coll);
+
+                LocalParticle_set_zeta(part, zeta_in);
+                // Hit and survived particles need correcting:
+                if (is_hit!=0 && LocalParticle_get_state(part)>0){
+                    // Update energy
+                    double ptau_out = (energy/mass_ratio - e0) / p0;
+                    LocalParticle_update_ptau(part, ptau_out);
+                    // Update zeta
+#ifdef XCOLL_USE_EXACT
+                    double xp  = LocalParticle_get_exact_xp(part);
+                    double yp  = LocalParticle_get_exact_yp(part);
+#else
+                    double xp  = LocalParticle_get_xp(part);
+                    double yp  = LocalParticle_get_yp(part);
+#endif
+                    double rvv = LocalParticle_get_rvv(part);
+                    // First we drift half the length with the old angles:
+                    LocalParticle_add_to_zeta(part, drift_zeta_single(rvv_in, xp_in, yp_in, length/2) );
+                    // then half the length with the new angles:
+                    LocalParticle_add_to_zeta(part, drift_zeta_single(rvv, xp, yp, length/2) );
+                }
+            }
+        }
+    //end_per_particle_block
+    EverestCollimator_free(cg, active);
+    free(coll);
+}
+
+
+#endif /* XCOLL_EVEREST_COLL_H */

xcoll/beam_elements/elements_src/everest_crystal.h

@@ -0,0 +1,280 @@
+// copyright ############################### #
+// This file is part of the Xcoll Package.   #
+// Copyright (c) CERN, 2024.                 #
+// ######################################### #
+
+#ifndef XCOLL_EVEREST_CRYSTAL_H
+#define XCOLL_EVEREST_CRYSTAL_H
+#include <math.h>
+#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);
+    RandomRutherford_set_by_xcoll_material(rng, (GeneralMaterialData) material);
+}
+
+
+/*gpufun*/
+CrystalGeometry EverestCrystal_init_geometry(EverestCrystalData el, LocalParticle* part0, int8_t active){
+    CrystalGeometry cg = (CrystalGeometry) malloc(sizeof(CrystalGeometry_));
+    if (active){ // This is needed in order to avoid that the initialisation is called during a twiss!
+        cg->length = EverestCrystalData_get_length(el);
+        cg->side   = EverestCrystalData_get__side(el);
+        if (cg->side == 0){
+            kill_all_particles(part0, XC_ERR_INVALID_XOFIELD);
+            return cg;
+        }
+        double R   = EverestCrystalData_get__bending_radius(el);
+        double t_R = EverestCrystalData_get__bending_angle(el);
+        cg->bending_radius = R;
+        cg->bending_angle  = t_R;
+        cg->miscut_angle   = EverestCrystalData_get_miscut(el);
+        cg->width  = EverestCrystalData_get_width(el);
+        cg->height = EverestCrystalData_get_height(el);
+        cg->jaw_U  = EverestCrystalData_get__jaw_U(el);
+        cg->sin_z  = EverestCrystalData_get__sin_z(el);
+        cg->cos_z  = EverestCrystalData_get__cos_z(el);
+        cg->sin_y  = EverestCrystalData_get__sin_y(el);
+        cg->cos_y  = EverestCrystalData_get__cos_y(el);
+        // Segments
+        if (cg->side == 1){
+            cg->segments = create_crystal(cg->bending_radius, cg->width, cg->length, cg->jaw_U, \
+                                          cg->sin_y, cg->cos_y);
+        } else if (cg->side == -1){
+            // jaw_U is the inner corner (shifted if right-sided crystal)
+            cg->segments = create_crystal(cg->bending_radius, cg->width, cg->length, cg->jaw_U - cg->width, \
+                                          cg->sin_y, cg->cos_y);
+        }
+        // Bend centre
+        cg->s_B = 0;
+        cg->x_B = cg->bending_radius;
+        // Miscut centre
+        cg->s_P = -R*sin(cg->miscut_angle);
+        cg->x_P = R*cos(cg->miscut_angle);
+        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;
+        }
+        // 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
+        // need to transform the particle to the jaw reference frame.
+        double Rb;
+        if (cg->miscut_angle > 0){
+            Rb = R - cg->width;
+        } else {
+            Rb = R;
+        }
+        cg->t_VImax = atan( (Rb*sin(t_R) - cg->s_P) / (R - Rb*cos(t_R) - cg->x_P) );
+        // Impact table
+        cg->record = EverestCrystalData_getp_internal_record(el, part0);
+        cg->record_index = NULL;
+        cg->record_impacts = 0;
+        cg->record_exits = 0;
+        if (cg->record){
+            cg->record_index = InteractionRecordData_getp__index(cg->record);
+            cg->record_impacts = EverestCrystalData_get_record_impacts(el);
+            cg->record_exits = EverestCrystalData_get_record_exits(el);
+        }
+    }
+
+    return cg;
+}
+
+/*gpufun*/
+void EverestCrystal_free(CrystalGeometry restrict cg, int8_t active){
+    if (active){
+        destroy_crystal(cg->segments);
+    }
+    free(cg);
+}
+
+
+// TODO: it would be great if we could set EverestData as an xofield, because then we could
+// run this function at creation of the collimator instead of every turn
+/*gpufun*/
+EverestCollData EverestCrystal_init(EverestCrystalData el, LocalParticle* part0, int8_t active){
+    EverestCollData coll = (EverestCollData) malloc(sizeof(EverestCollData_));
+    if (active){ // This is needed in order to avoid that the initialisation is called during a twiss!
+        // Random generator and material
+        coll->rng = EverestCrystalData_getp_rutherford_rng(el);
+        CrystalMaterialData material = EverestCrystalData_getp__material(el);
+        coll->exenergy = CrystalMaterialData_get_excitation_energy(material)*1.0e3; // MeV
+        coll->rho      = CrystalMaterialData_get_density(material);
+        coll->anuc     = CrystalMaterialData_get_A(material);
+        coll->zatom    = CrystalMaterialData_get_Z(material);
+        coll->bnref    = CrystalMaterialData_get_nuclear_elastic_slope(material);
+        coll->csref[0] = CrystalMaterialData_get_cross_section(material, 0);
+        coll->csref[1] = CrystalMaterialData_get_cross_section(material, 1);
+        coll->csref[5] = CrystalMaterialData_get_cross_section(material, 5);
+        coll->dlri     = CrystalMaterialData_get_crystal_radiation_length(material);
+        coll->dlyi     = CrystalMaterialData_get_crystal_nuclear_length(material);
+        coll->ai       = CrystalMaterialData_get_crystal_plane_distance(material);
+        coll->eum      = CrystalMaterialData_get_crystal_potential(material);
+        coll->collnt   = CrystalMaterialData_get_nuclear_collision_length(material);
+        coll->eta      = 0.9;  // Hard-coded channeling saturation factor
+        coll->orient   = EverestCrystalData_get__orient(el);
+        // Impact table
+        coll->record = EverestCrystalData_getp_internal_record(el, part0);
+        coll->record_index = NULL;
+        if (coll->record){
+            coll->record_index = InteractionRecordData_getp__index(coll->record);
+            coll->record_scatterings = EverestCrystalData_get_record_scatterings(el);
+        }
+    }
+    return coll;
+}
+
+
+/*gpufun*/
+EverestData EverestCrystal_init_data(LocalParticle* part, EverestCollData restrict coll, CrystalGeometry restrict cg){
+    EverestData everest = (EverestData) malloc(sizeof(EverestData_));
+    everest->coll = coll;
+    everest->rescale_scattering = 1;
+#ifndef XCOLL_REFINE_ENERGY
+    // Preinitialise scattering parameters
+    double charge_ratio = LocalParticle_get_charge_ratio(part);
+    double mass_ratio = charge_ratio / LocalParticle_get_chi(part);
+    double energy = ( LocalParticle_get_ptau(part) + 1 / LocalParticle_get_beta0(part)
+                     ) * mass_ratio * LocalParticle_get_p0c(part) / 1e9; // energy in GeV
+    calculate_scattering(everest, energy);
+    calculate_ionisation_properties(everest, energy);
+    calculate_critical_angle(everest, part, cg, energy);
+    calculate_VI_parameters(everest, part, energy);
+#endif
+    return everest;
+}
+
+
+/*gpufun*/
+void EverestCrystal_track_local_particle(EverestCrystalData el, LocalParticle* part0) {
+    int8_t active = EverestCrystalData_get_active(el);
+    active       *= EverestCrystalData_get__tracking(el);
+    double length = EverestCrystalData_get_length(el);
+
+    // Initialise collimator data
+    // TODO: we want this to happen before tracking (instead of every turn), as a separate kernel
+    EverestCollData coll = EverestCrystal_init(el, part0, active);
+    CrystalGeometry cg   = EverestCrystal_init_geometry(el, part0, active);
+
+    double t_c = 0;
+
+    //start_per_particle_block (part0->part)
+        if (!active){
+            // Drift full length
+            Drift_single_particle(part, length);
+
+        } else {
+            // Check collimator initialisation
+            int8_t is_valid = xcoll_check_particle_init(coll->rng, part);
+
+            if (is_valid) {
+                double const s_coll = LocalParticle_get_s(part);
+                LocalParticle_set_s(part, 0);
+
+                // Store initial coordinates for updating later
+                double const e0         = LocalParticle_get_energy0(part);
+                double const p0         = LocalParticle_get_p0c(part);
+                double const ptau_in    = LocalParticle_get_ptau(part);
+                double const rvv_in     = LocalParticle_get_rvv(part);
+#ifdef XCOLL_USE_EXACT
+                double const xp_in      = LocalParticle_get_exact_xp(part);
+                double const yp_in      = LocalParticle_get_exact_yp(part);
+#else
+                double const xp_in      = LocalParticle_get_xp(part);
+                double const yp_in      = LocalParticle_get_yp(part);
+#endif
+                double const zeta_in    = LocalParticle_get_zeta(part);
+                double const mass_ratio = LocalParticle_get_charge_ratio(part) / LocalParticle_get_chi(part);   // m/m0
+                double energy           = (p0*ptau_in + e0) * mass_ratio;
+
+                // Check if hit on jaws
+                int8_t is_hit = hit_crystal_check_and_transform(part, cg);
+
+                if (is_hit != 0) {
+                    // Hit one of the jaws, so scatter
+                    double remaining_length = length - LocalParticle_get_s(part);
+                    // Scatter
+                    EverestData everest = EverestCrystal_init_data(part0, coll, cg);
+                    calculate_initial_angle(everest, part, cg);
+#ifdef XCOLL_USE_EXACT
+                    double const xp = LocalParticle_get_exact_xp(part);
+#else
+                    double const xp = LocalParticle_get_xp(part);
+#endif
+                    if (fabs(xp - everest->t_I) < everest->t_c) {
+                        energy = Channel(everest, part, cg, energy/1.e9, remaining_length)*1.e9;
+                    } else {
+                        energy = Amorphous(everest, part, cg, energy/1.e9, remaining_length)*1.e9;
+                    }
+                    // Temporary workaround to store the critical angle for use later
+                    calculate_critical_angle(everest, part, cg, e0/1.e9);
+                    t_c = everest->t_c;
+                    free(everest);
+                }
+
+                // Transform back to the lab frame
+                hit_crystal_transform_back(is_hit, part, cg);
+                LocalParticle_add_to_s(part, s_coll);
+
+                LocalParticle_set_zeta(part, zeta_in);
+                // Hit and survived particles need correcting:
+                if (is_hit!=0 && LocalParticle_get_state(part)>0){
+                    // Update energy
+                    double ptau_out = (energy/mass_ratio - e0) / p0;
+                    LocalParticle_update_ptau(part, ptau_out);
+                    // Update zeta
+#ifdef XCOLL_USE_EXACT
+                    double xp  = LocalParticle_get_exact_xp(part);
+                    double yp  = LocalParticle_get_exact_yp(part);
+#else
+                    double xp  = LocalParticle_get_xp(part);
+                    double yp  = LocalParticle_get_yp(part);
+#endif
+                    double rvv = LocalParticle_get_rvv(part);
+                    // First we drift half the length with the old angles:
+                    LocalParticle_add_to_zeta(part, drift_zeta_single(rvv_in, xp_in, yp_in, length/2) );
+                    // then half the length with the new angles:
+                    LocalParticle_add_to_zeta(part, drift_zeta_single(rvv, xp, yp, length/2) );
+                }
+            }
+        }
+    //end_per_particle_block
+    EverestCrystalData_set__critical_angle(el, t_c);
+    EverestCrystal_free(cg, active);
+    free(coll);
+}
+
+
+#endif /* XCOLL_EVEREST_CRYSTAL_H */