xcoll 0.5.11__py3-none-any.whl → 0.6.0__py3-none-any.whl

xcoll/beam_elements/elements_src/everest_crystal.h

@@ -33,90 +33,87 @@ void EverestCrystal_set_material(EverestCrystalData el){
 
 
 /*gpufun*/
-CrystalGeometry EverestCrystal_init_geometry(EverestCrystalData el, LocalParticle* part0, int8_t active){
+CrystalGeometry EverestCrystal_init_geometry(EverestCrystalData el, LocalParticle* part0){
     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);
-        }
+    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);
+    }
+    // // Jaw frame is always left-sided
+    // cg->segments_jf = create_crystal(cg->bending_radius, cg->width, cg->length, 0, 0, 1);
+    // 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);
-    }
+void EverestCrystal_free(CrystalGeometry restrict cg){
+    destroy_crystal(cg->segments);
     free(cg);
 }
 
@@ -124,35 +121,33 @@ void EverestCrystal_free(CrystalGeometry restrict cg, int8_t active){
 // 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 EverestCrystal_init(EverestCrystalData el, LocalParticle* part0){
     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->only_mcs = CrystalMaterialData_get__only_mcs(material);
-        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);
-        }
+    // 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->only_mcs = CrystalMaterialData_get__only_mcs(material);
+    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;
 }
@@ -180,17 +175,25 @@ void EverestCrystal_track_local_particle(EverestCrystalData el, LocalParticle* p
     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);
+    EverestCollData coll;
+    CrystalGeometry cg;
+    if (active){
+        // TODO: we want this to happen before tracking (instead of every turn), as a separate kernel
+        coll = EverestCrystal_init(el, part0);
+        cg   = EverestCrystal_init_geometry(el, part0);
 
-    // For info
-    double const e0 = LocalParticle_get_energy0(part0);
-    double t_c0  = _critical_angle0(coll, e0);
-    double Rcrit = _critical_radius(coll, e0);
-    double t_c = _critical_angle(coll, t_c0, Rcrit / fabs(cg->bending_radius));
-    EverestCrystalData_set__critical_radius(el, Rcrit);
-    EverestCrystalData_set__critical_angle(el, t_c);
+        // For info
+        double const e0 = LocalParticle_get_energy0(part0);
+        double t_c0  = _critical_angle0(coll, e0);
+        double Rcrit = _critical_radius(coll, e0);
+        double t_c = _critical_angle(coll, t_c0, Rcrit / fabs(cg->bending_radius));
+        EverestCrystalData_set__critical_radius(el, Rcrit);
+        EverestCrystalData_set__critical_angle(el, t_c);
+
+        if (cg->width==0 || cg->height==0 || cg->bending_radius==0){
+            kill_all_particles(part0, XC_ERR_INVALID_XOFIELD);
+        }
+    }
 
     //start_per_particle_block (part0->part)
         if (!active){
@@ -207,17 +210,21 @@ void EverestCrystal_track_local_particle(EverestCrystalData el, LocalParticle* p
                 LocalParticle_set_s(part, 0);
 
                 // Store initial coordinates for updating later
-                double const rvv_in     = LocalParticle_get_rvv(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);
+                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);
+                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 energy_in  = LocalParticle_get_energy(part);
-                double energy_out;
+                double const zeta_in = LocalParticle_get_zeta(part);
+                double const p0c     = LocalParticle_get_p0c(part);
+                double const delta   = LocalParticle_get_delta(part);
+                double const qq0     = LocalParticle_get_charge_ratio(part);
+                double const chi     = LocalParticle_get_chi(part);
+                double const pc_in   = (1 + delta)*p0c*qq0/chi;
+                double pc_out;
 
                 // Check if hit on jaws
                 int8_t is_hit = hit_crystal_check_and_transform(part, cg);
@@ -227,17 +234,7 @@ void EverestCrystal_track_local_particle(EverestCrystalData el, LocalParticle* p
                     double remaining_length = length - LocalParticle_get_s(part);
                     // Scatter
                     EverestData everest = EverestCrystal_init_data(part, 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_out = Channel(everest, part, cg, energy_in/1.e9, remaining_length)*1.e9;
-                    } else {
-                        energy_out = Amorphous(everest, part, cg, energy_in/1.e9, remaining_length, 1)*1.e9;
-                    }
+                    pc_out = do_crystal(everest, part, cg, pc_in/1.e9, remaining_length)*1.e9;
                     free(everest);
                 }
 
@@ -246,10 +243,16 @@ void EverestCrystal_track_local_particle(EverestCrystalData el, LocalParticle* p
                 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; the last flag keeps angles constant (even valid for exact angles!)
-                    LocalParticle_add_to_energy(part, energy_out - energy_in, 0);
+                    double const rpp_old  = LocalParticle_get_rpp(part);
+                    LocalParticle_update_delta(part, pc_out*chi/p0c/qq0 - 1);
+                    // Keep angles constant (this is also correct for exact angles): px_new = px_old*(1 + δ_new)/(1 + δ_old)
+                    double const scale = rpp_old / LocalParticle_get_rpp(part);
+                    LocalParticle_scale_px(part, scale);
+                    LocalParticle_scale_py(part, scale);
+
                     // Update zeta
 #ifdef XCOLL_USE_EXACT
                     double xp  = LocalParticle_get_exact_xp(part);
@@ -267,9 +270,11 @@ void EverestCrystal_track_local_particle(EverestCrystalData el, LocalParticle* p
             }
         }
     //end_per_particle_block
-    EverestCrystal_free(cg, active);
-    free(coll);
+    if (active){
+        EverestCrystal_free(cg);
+        free(coll);
+    }
 }
 
 
-#endif /* XCOLL_EVEREST_CRYSTAL_H */
+#endif /* XCOLL_EVEREST_CRYSTAL_H */

xcoll/beam_elements/elements_src/transparent_collimator.h

@@ -0,0 +1,126 @@
+// copyright ############################### #
+// This file is part of the Xcoll package.   #
+// Copyright (c) CERN, 2025.                 #
+// ######################################### #
+
+#ifndef XCOLL_TRANSPARENT_COLL_H
+#define XCOLL_TRANSPARENT_COLL_H
+
+
+/*gpufun*/
+int8_t TransparentCollimatorData_get_record_impacts(TransparentCollimatorData el){
+    return TransparentCollimatorData_get__record_interactions(el) % 2;
+}
+
+/*gpufun*/
+int8_t TransparentCollimatorData_get_record_exits(TransparentCollimatorData el){
+    return (TransparentCollimatorData_get__record_interactions(el) >> 1) % 2;
+}
+
+/*gpufun*/
+int8_t TransparentCollimatorData_get_record_scatterings(TransparentCollimatorData el){
+    return (TransparentCollimatorData_get__record_interactions(el) >> 2) % 2;
+}
+
+
+/*gpufun*/
+CollimatorGeometry TransparentCollimator_init_geometry(TransparentCollimatorData el, LocalParticle* part0){
+    CollimatorGeometry cg = (CollimatorGeometry) malloc(sizeof(CollimatorGeometry_));
+    // Jaw corners (with tilts)
+    cg->jaw_LU = TransparentCollimatorData_get__jaw_LU(el);
+    cg->jaw_RU = TransparentCollimatorData_get__jaw_RU(el);
+    // Get angles of jaws
+    cg->sin_zL = TransparentCollimatorData_get__sin_zL(el);
+    cg->cos_zL = TransparentCollimatorData_get__cos_zL(el);
+    cg->sin_zR = TransparentCollimatorData_get__sin_zR(el);
+    cg->cos_zR = TransparentCollimatorData_get__cos_zR(el);
+    cg->sin_zDiff = TransparentCollimatorData_get__sin_zDiff(el);
+    cg->cos_zDiff = TransparentCollimatorData_get__cos_zDiff(el);
+    cg->jaws_parallel = TransparentCollimatorData_get__jaws_parallel(el);
+    // Tilts
+    cg->sin_yL = TransparentCollimatorData_get__sin_yL(el);
+    cg->cos_yL = TransparentCollimatorData_get__cos_yL(el);
+    cg->sin_yR = TransparentCollimatorData_get__sin_yR(el);
+    cg->cos_yR = TransparentCollimatorData_get__cos_yR(el);
+    // Length and segments
+    cg->length = TransparentCollimatorData_get_length(el);
+    cg->side   = TransparentCollimatorData_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 = TransparentCollimatorData_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 = TransparentCollimatorData_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 = TransparentCollimatorData_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 = TransparentCollimatorData_get_record_impacts(el);
+        cg->record_exits = TransparentCollimatorData_get_record_exits(el);
+    }
+    return cg;
+}
+
+/*gpufun*/
+void TransparentCollimator_free(CollimatorGeometry restrict cg){
+    if (cg->side != -1){
+        destroy_jaw(cg->segments_L);
+    }
+    if (cg->side != 1){
+        destroy_jaw(cg->segments_R);
+    }
+    free(cg);
+}
+
+
+/*gpufun*/
+void TransparentCollimator_track_local_particle(TransparentCollimatorData el, LocalParticle* part0){
+    int8_t active = TransparentCollimatorData_get_active(el);
+    active       *= TransparentCollimatorData_get__tracking(el);
+    double const length = TransparentCollimatorData_get_length(el);
+
+    // Get geometry
+    CollimatorGeometry cg;
+    if (active){
+        cg = TransparentCollimator_init_geometry(el, part0);
+    }
+
+    //start_per_particle_block (part0->part)
+        if (!active){
+            // Drift full length
+            Drift_single_particle(part, length);
+
+        } else {
+            // Check collimator initialisation
+            int8_t is_tracking = assert_tracking(part, XC_ERR_INVALID_TRACK);
+
+            if (is_tracking) {
+                // Store s-location of start of collimator
+                double s_coll = LocalParticle_get_s(part);
+                LocalParticle_set_s(part, 0);
+
+                // Check if hit on jaws
+                int8_t is_hit = hit_jaws_check_and_transform(part, cg);
+
+                // Transform back to the lab frame
+                hit_jaws_transform_back(is_hit, part, cg);
+                LocalParticle_add_to_s(part, s_coll);
+            }
+        }
+    //end_per_particle_block
+    if (active){
+        TransparentCollimator_free(cg);
+    }
+}
+
+#endif /* XCOLL_TRANSPARENT_COLL_H */

xcoll/beam_elements/elements_src/transparent_crystal.h

@@ -0,0 +1,118 @@
+// copyright ############################### #
+// This file is part of the Xcoll package.   #
+// Copyright (c) CERN, 2025.                 #
+// ######################################### #
+
+#ifndef XCOLL_TRANSPAREN_CRY_H
+#define XCOLL_TRANSPAREN_CRY_H
+
+
+/*gpufun*/
+int8_t TransparentCrystalData_get_record_impacts(TransparentCrystalData el){
+    return TransparentCrystalData_get__record_interactions(el) % 2;
+}
+
+/*gpufun*/
+int8_t TransparentCrystalData_get_record_exits(TransparentCrystalData el){
+    return (TransparentCrystalData_get__record_interactions(el) >> 1) % 2;
+}
+
+/*gpufun*/
+int8_t TransparentCrystalData_get_record_scatterings(TransparentCrystalData el){
+    return (TransparentCrystalData_get__record_interactions(el) >> 2) % 2;
+}
+
+
+/*gpufun*/
+CrystalGeometry TransparentCrystal_init_geometry(TransparentCrystalData el, LocalParticle* part0){
+    CrystalGeometry cg = (CrystalGeometry) malloc(sizeof(CrystalGeometry_));
+    cg->length = TransparentCrystalData_get_length(el);
+    cg->side   = TransparentCrystalData_get__side(el);
+    cg->bending_radius = TransparentCrystalData_get__bending_radius(el);
+    cg->bending_angle  = TransparentCrystalData_get__bending_angle(el);
+    cg->width  = TransparentCrystalData_get__width(el);
+    cg->height = TransparentCrystalData_get__height(el);
+    cg->jaw_U  = TransparentCrystalData_get__jaw_U(el);
+    cg->sin_z  = TransparentCrystalData_get__sin_z(el);
+    cg->cos_z  = TransparentCrystalData_get__cos_z(el);
+    cg->sin_y  = TransparentCrystalData_get__sin_y(el);
+    cg->cos_y  = TransparentCrystalData_get__cos_y(el);
+    double jaw;
+    if (cg->side == 1){
+        jaw = cg->jaw_U;
+    } else if (cg->side == -1){
+        jaw = cg->jaw_U - cg->width;   // To ensure that jaw_U is the inner corner
+    } else {
+        kill_all_particles(part0, XC_ERR_INVALID_XOFIELD);
+        return cg;
+    }
+    cg->segments = create_crystal(cg->bending_radius, cg->width, cg->length, jaw, cg->sin_y, cg->cos_y);
+    // Impact table
+    cg->record = TransparentCrystalData_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 = TransparentCrystalData_get_record_impacts(el);
+        cg->record_exits = TransparentCrystalData_get_record_exits(el);
+    }
+    // Not needed, set to zero
+    cg->miscut_angle = 0;
+    cg->s_P = 0;
+    cg->x_P = 0;
+    cg->t_VImax = 0;
+    return cg;
+}
+
+/*gpufun*/
+void TransparentCrystal_free(CrystalGeometry restrict cg){
+    destroy_crystal(cg->segments);
+    free(cg);
+}
+
+
+/*gpufun*/
+void TransparentCrystal_track_local_particle(TransparentCrystalData el, LocalParticle* part0){
+    int8_t active = TransparentCrystalData_get_active(el);
+    active       *= TransparentCrystalData_get__tracking(el);
+    double const length = TransparentCrystalData_get_length(el);
+
+    // Get geometry
+    CrystalGeometry cg;
+    if (active){
+        cg = TransparentCrystal_init_geometry(el, part0);
+        if (cg->width==0 || cg->height==0 || cg->bending_radius==0){
+            kill_all_particles(part0, XC_ERR_INVALID_XOFIELD);
+        }
+    }
+
+    //start_per_particle_block (part0->part)
+        if (!active){
+            // Drift full length
+            Drift_single_particle(part, length);
+
+        } else {
+            // Check collimator initialisation
+            int8_t is_tracking = assert_tracking(part, XC_ERR_INVALID_TRACK);
+
+            if (is_tracking) {
+                // Store s-location of start of collimator
+                double s_coll = LocalParticle_get_s(part);
+                LocalParticle_set_s(part, 0);
+
+                // Check if hit on jaws
+                int8_t is_hit = hit_crystal_check_and_transform(part, cg);
+
+                // Transform back to the lab frame
+                hit_crystal_transform_back(is_hit, part, cg);
+                LocalParticle_add_to_s(part, s_coll);
+            }
+        }
+    //end_per_particle_block
+    if (active){
+        TransparentCrystal_free(cg);
+    }
+}
+
+#endif /* XCOLL_TRANSPAREN_CRY_H */

xcoll/beam_elements/everest.py

@@ -31,11 +31,15 @@ class EverestBlock(BaseBlock):
     isthick = True
     needs_rng = True
     allow_track = True
+    allow_double_sided = False
     behaves_like_drift = True
+    allow_rot_and_shift = False
+    allow_loss_refinement = True
     skip_in_loss_location_refinement = True
 
-    _skip_in_to_dict       = ['_material']
-    _store_in_to_dict      = ['material']
+    _noexpr_fields         = {'material'}
+    _skip_in_to_dict       = [*BaseBlock._skip_in_to_dict, '_material']
+    _store_in_to_dict      = [*BaseBlock._store_in_to_dict, 'material']
     _internal_record_class = BaseBlock._internal_record_class
 
     _depends_on = [BaseBlock, EverestEngine]
@@ -95,11 +99,15 @@ class EverestCollimator(BaseCollimator):
     isthick = True
     needs_rng = True
     allow_track = True
+    allow_double_sided = True
     behaves_like_drift = True
+    allow_rot_and_shift = False
+    allow_loss_refinement = True
     skip_in_loss_location_refinement = True
 
-    _skip_in_to_dict       = [ *BaseCollimator._skip_in_to_dict, '_material' ]
-    _store_in_to_dict      = [ *BaseCollimator._store_in_to_dict, 'material' ]
+    _noexpr_fields         = {*BaseCollimator._noexpr_fields, 'material'}
+    _skip_in_to_dict       = [*BaseCollimator._skip_in_to_dict, '_material']
+    _store_in_to_dict      = [*BaseCollimator._store_in_to_dict, 'material']
     _internal_record_class = BaseCollimator._internal_record_class
 
     _depends_on = [BaseCollimator, EverestEngine]
@@ -148,7 +156,6 @@ class EverestCollimator(BaseCollimator):
                             _buffer=_buffer, _offset=_offset)
 
 
-
 class EverestCrystal(BaseCrystal):
     _xofields = {**BaseCrystal._xofields,
         'miscut':             xo.Float64,
@@ -163,9 +170,13 @@ class EverestCrystal(BaseCrystal):
     isthick = True
     needs_rng = True
     allow_track = True
+    allow_double_sided = False
     behaves_like_drift = True
+    allow_rot_and_shift = False
+    allow_loss_refinement = True
     skip_in_loss_location_refinement = True
 
+    _noexpr_fields         = {*BaseCrystal._noexpr_fields, 'material', 'lattice'}
     _skip_in_to_dict       = [*BaseCrystal._skip_in_to_dict, '_orient', '_material']
     _store_in_to_dict      = [*BaseCrystal._store_in_to_dict, 'lattice', 'material']
     _internal_record_class = BaseCrystal._internal_record_class