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

xcoll/scattering_routines/everest/{channeling.h → channelling.h}

@@ -3,8 +3,8 @@
 // Copyright (c) CERN, 2023.                 #
 // ######################################### #
 
-#ifndef XCOLL_EVEREST_CHANNELING_H
-#define XCOLL_EVEREST_CHANNELING_H
+#ifndef XCOLL_EVEREST_CHANNELLING_H
+#define XCOLL_EVEREST_CHANNELLING_H
 #include <math.h>
 #include <stdio.h>
 #include <stdlib.h>
@@ -18,7 +18,7 @@
 
 
 /*gpufun*/
-double channeling_average_density(EverestData restrict everest, CrystalGeometry restrict cg, LocalParticle* part, double pc) {
+double channelling_average_density(EverestData restrict everest, CrystalGeometry restrict cg, LocalParticle* part, double pc) {
 
     // Material properties
     double const anuc = everest->coll->anuc;
@@ -75,12 +75,12 @@ double channeling_average_density(EverestData restrict everest, CrystalGeometry
 
 /*gpufun*/
 double* channel_transport(EverestData restrict everest, LocalParticle* part, double pc, double L_chan, double t_I, double t_P) {
-    // Channeling: happens over an arc length L_chan (potentially less if dechanneling)
+    // Channelling: happens over an arc length L_chan (potentially less if dechannelling)
     //             This equates to an opening angle t_P wrt. to the point P (center of miscut if at start of crystal)
-    //             The chord angle xp at the start of channeling (I) is t_P/2 + t_I
-    //             The angle xp at the end of channeling (F) is t_P + t_I
+    //             The chord angle xp at the start of channelling (I) is t_P/2 + t_I
+    //             The angle xp at the end of channelling (F) is t_P + t_I
     //             In practice: we drift from start to end, but overwrite the angle afterwards
-    // TODO: why does channeling only have 50% energy loss?
+    // TODO: why does channelling only have 50% energy loss?
 
     double* result = (double*)malloc(2 * sizeof(double));
 
@@ -88,33 +88,37 @@ double* channel_transport(EverestData restrict everest, LocalParticle* part, dou
     RecordIndex record_index     = everest->coll->record_index;
     int8_t sc = everest->coll->record_scatterings;
 
-    // First log particle at start of channeling
+    // First log particle at start of channelling
     int64_t i_slot = -1;
-    if (sc) i_slot = InteractionRecordData_log(record, record_index, part, XC_CHANNELING);
+    if (sc) i_slot = InteractionRecordData_log(record, record_index, part, XC_CHANNELLING);
 
-    // Do channeling.
+    // Do channelling.
     // The distance from I to F is the chord length of the angle t_P: d = 2 r sin(t_P/2)
     // Hence the longitudinal distance (the length to be drifted) is the projection of this using the
-    // xp at the start of channeling: s = 2 r sin(t_P/2)cos(t_P/2 + t_I)
+    // xp at the start of channelling: s = 2 r sin(t_P/2)cos(t_P/2 + t_I)
     double t_chord= t_I + t_P/2.;
     double drift_length = 2.*L_chan/t_P * sin(t_P/2.) * cos(t_chord);
-    LocalParticle_set_xp(part, t_chord);          // Angle at start of channeling
+    LocalParticle_set_xp(part, t_chord);          // Angle at start of channelling
     Drift_single_particle_4d(part, drift_length);
-    // In reality,the particle oscillates horizontally between the planes while channeling.
+    // In reality,the particle oscillates horizontally between the planes while channelling.
     // This effect is mimicked by giving a random angle spread at the exit
     double sigma_ran = 0.5*everest->t_c;
-    double ran_angle = RandomNormal_generate(part)*sigma_ran;
-    LocalParticle_set_xp(part, t_I + t_P + ran_angle); // Angle at end of channeling
+    double ran = RandomNormal_generate(part);
+    while (fabs(ran) > 2.0) {
+        // Ensure that the kick is within [-tc, +tc]
+        ran = RandomNormal_generate(part);
+    }
+    double ran_angle = ran*sigma_ran;
+    LocalParticle_set_xp(part, t_I + t_P + ran_angle); // Angle at end of channelling
 
     // Apply energy loss along trajectory
-    double energy_loss = 0.5*calcionloss(everest, part, L_chan);
-    // TODO: LocalParticle_add_to_energy(part, - energy_loss*L_chan*1.e9, change_angle);
+    pc = calcionloss(everest, part, L_chan, pc, 0.5);
+    // TODO: LocalParticle_add_to_energy(part, - energy_loss*1.e9, change_angle);
     // if change_angle = 0  => LocalParticle_scale_px(part, old_rpp / new_rpp) such that xp remains the same
     // It is done in K2, so we should do it. Though, it seems that with the current implementation in xtrack
     // this is no longer correct with exact drifts...?
-    pc = pc - energy_loss*L_chan; //energy loss to ionization [GeV]
 
-    // Finally log particle at end of channeling
+    // Finally log particle at end of channelling
     if (sc) InteractionRecordData_log_child(record, i_slot, part);
 
     result[0] = drift_length;
@@ -123,118 +127,123 @@ double* channel_transport(EverestData restrict everest, LocalParticle* part, dou
 }
 
 
-double Channel(EverestData restrict everest, LocalParticle* part, CrystalGeometry restrict cg, double pc, double length) {
-
-    if (LocalParticle_get_state(part) < 1){
-        // Do nothing if already absorbed
-        return pc;
-    }
-
-    InteractionRecordData record = everest->coll->record;
-    RecordIndex record_index     = everest->coll->record_index;
-    int8_t sc = everest->coll->record_scatterings;
-
+double do_crystal(EverestData restrict everest, LocalParticle* part, CrystalGeometry restrict cg, double pc, double length) {
     calculate_initial_angle(everest, part, cg);
+    calculate_opening_angle(everest, part, cg);
 #ifdef XCOLL_REFINE_ENERGY
     calculate_critical_angle(everest, part, cg, pc);
 #endif
-
-    // Do we channel, or are we in the transition between channeling and VR?
-    double xp = LocalParticle_get_xp(part);
-    double alpha = fabs(xp - everest->t_I) / everest->t_c;
-    double ratio = everest->Rc_over_R;
-    double xi = RandomUniform_generate(part)/(1 - ratio)/sqrt(everest->coll->eta);
-
-    if (xi > 1 || alpha > 2*sqrt(xi)*sqrt(1-xi)) {
-#ifdef XCOLL_TRANSITION
-        // TRANSITION
-        // We feel that this transition is not needed, as it interpolates between two regions
-        // (adding a slant below the channeling region) which does not seem to be present in
-        // experimental data.
+#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) {
+        double alpha = fabs(xp - everest->t_I) / everest->t_c;
+        double ratio = everest->Rc_over_R;
+        double xi = RandomUniform_generate(part)/(1 - ratio)/sqrt(everest->coll->eta);
+        if (xi > 1 || alpha > 2*sqrt(xi)*sqrt(1-xi)) {
+#ifdef XCOLL_TRANSITION_VRCH
 #ifdef XCOLL_REFINE_ENERGY
-        calculate_VI_parameters(everest, part, pc);
+            calculate_VI_parameters(everest, part, pc);
 #endif
-        volume_reflection(everest, part, XC_VOLUME_REFLECTION_TRANS_CH);
+            volume_reflection(everest, part, XC_VOLUME_REFLECTION_TRANS_CH);
 #endif
+            pc = Amorphous(everest, part, cg, pc, length, 1);
+        } else {
+            pc = Channel(everest, part, cg, pc, length);
+        }
+    } else {
         pc = Amorphous(everest, part, cg, pc, length, 1);
+    }
+    return pc;
+}
+
+double Channel(EverestData restrict everest, LocalParticle* part, CrystalGeometry restrict cg, double pc, double length) {
+    if (LocalParticle_get_state(part) < 1){
+        // Do nothing if already absorbed
+        return pc;
+    }
 
+    // CHANNEL
+    double t_I = everest->t_I;
+    double t_P = everest->t_P;
+    double L_chan = everest->r*t_P;
+    double ratio = everest->Rc_over_R;
+
+    // ------------------------------------------------
+    // Calculate curved length L_dechan of dechannelling
+    // ------------------------------------------------
+    double const_dech = calculate_dechannelling_length(everest, pc);
+    double TLdech1 = const_dech*pc*pow(1. - ratio, 2.); //Updated calculate typical dech. length(m)
+    double N_atom = 1.0e-1;
+    if(RandomUniform_generate(part) <= N_atom) {
+        TLdech1 /= 200.;   // Updated dechannelling length (m)
+    }
+    double L_dechan = TLdech1*RandomExponential_generate(part);   // Actual dechan. length
+
+    // -----------------------------------------------------
+    // Calculate curved length L_nucl of nuclear interaction
+    // -----------------------------------------------------
+    // Nuclear interaction length is rescaled in this case, because channelling
+    double collnt = everest->coll->collnt;
+    double avrrho = channelling_average_density(everest, cg, part, pc);
+    if (avrrho == 0) {
+        collnt = 1.e10;  // very large because essentially 1/0
     } else {
-        // CHANNEL
-        calculate_opening_angle(everest, part, cg);
-        double t_I = everest->t_I;
-        double t_P = everest->t_P;
-        double L_chan = everest->r*t_P;
-
-        // ------------------------------------------------
-        // Calculate curved length L_dechan of dechanneling
-        // ------------------------------------------------
-        double const_dech = calculate_dechanneling_length(everest, pc);
-        double TLdech1 = const_dech*pc*pow(1. - ratio, 2.); //Updated calculate typical dech. length(m)
-        double N_atom = 1.0e-1;
-        if(RandomUniform_generate(part) <= N_atom) {
-            TLdech1 /= 200.;   // Updated dechanneling length (m)      
-        }
-        double L_dechan = TLdech1*RandomExponential_generate(part);   // Actual dechan. length
-
-        // -----------------------------------------------------
-        // Calculate curved length L_nucl of nuclear interaction
-        // -----------------------------------------------------
-        // Nuclear interaction length is rescaled in this case, because channeling
-        double collnt = everest->coll->collnt;
-        double avrrho = channeling_average_density(everest, cg, part, pc);
-        if (avrrho == 0) {
-            collnt = 1.e10;  // very large because essentially 1/0
-        } else {
-            collnt = collnt/avrrho;
+        collnt = collnt/avrrho;
+    }
+    double L_nucl = collnt*RandomExponential_generate(part);
+
+    // ------------------------------------------------------------------------
+    // Compare the 3 lengths: the first one encountered is what will be applied
+    // ------------------------------------------------------------------------
+    if (L_chan <= fmin(L_dechan, L_nucl)){
+        // Channel full length
+        double* result_chan = channel_transport(everest, part, pc, L_chan, t_I, t_P);
+        // double channeled_length = result_chan[0];
+        pc = result_chan[1];
+        free(result_chan);
+
+    } else if (L_dechan < L_nucl) {
+        // Channel up to L_dechan, then amorphous
+        double* result_chan = channel_transport(everest, part, pc, L_dechan, t_I, t_P*L_dechan/L_chan);
+        double channeled_length = result_chan[0];
+        pc = result_chan[1];
+        free(result_chan);
+
+        if (everest->coll->record_scatterings){
+            InteractionRecordData record = everest->coll->record;
+            RecordIndex record_index     = everest->coll->record_index;
+            InteractionRecordData_log(record, record_index, part, XC_DECHANNELLING);
         }
-        double L_nucl = collnt*RandomExponential_generate(part);
-
-// printf("Channeling (%f -> %f):   L_c: %f,  L_d: %f,  L_n: %f\n", t_I, t_P, L_chan, L_dechan, L_nucl);
-        // ------------------------------------------------------------------------
-        // Compare the 3 lengths: the first one encountered is what will be applied
-        // ------------------------------------------------------------------------
-        if (L_chan <= fmin(L_dechan, L_nucl)){
-            // Channel full length
-            double* result_chan = channel_transport(everest, part, pc, L_chan, t_I, t_P);
-            // double channeled_length = result_chan[0];
-            pc               = result_chan[1];
-            free(result_chan);
-
-        } else if (L_dechan < L_nucl) {
-            // Channel up to L_dechan, then amorphous
-            double* result_chan = channel_transport(everest, part, pc, L_dechan, t_I, t_P*L_dechan/L_chan);
-            double channeled_length = result_chan[0];
-            pc               = result_chan[1];
-            free(result_chan);
-            if (sc) InteractionRecordData_log(record, record_index, part, XC_DECHANNELING);
-            pc = Amorphous(everest, part, cg, pc, length - channeled_length, 1);
+        pc = Amorphous(everest, part, cg, pc, length - channeled_length, 1);
 
-        } else {
-            // Channel up to L_nucl, then scatter, then amorphous
-            double* result_chan = channel_transport(everest, part, pc, L_nucl, t_I, t_P*L_nucl/L_chan);
-            double channeled_length = result_chan[0];
-            pc               = result_chan[1];
-            free(result_chan);
-            // Rescale nuclear interaction parameters
-            everest->rescale_scattering = avrrho;
+    } else {
+        // Channel up to L_nucl, then scatter, then amorphous
+        double* result_chan = channel_transport(everest, part, pc, L_nucl, t_I, t_P*L_nucl/L_chan);
+        double channeled_length = result_chan[0];
+        pc = result_chan[1];
+        free(result_chan);
+        // Rescale nuclear interaction parameters
+        everest->rescale_scattering = avrrho;
 #ifndef XCOLL_REFINE_ENERGY
-            calculate_scattering(everest, pc);
+        calculate_scattering(everest, pc);
 #endif
-            pc = nuclear_interaction(everest, part, pc);
-            if (LocalParticle_get_state(part) == XC_LOST_ON_EVEREST_COLL){
-                LocalParticle_set_state(part, XC_LOST_ON_EVEREST_CRYSTAL);
-            } else {
-                // We call the main Amorphous function for the leftover
-                everest->rescale_scattering = 1;
+        pc = nuclear_interaction(everest, part, pc);
+        if (LocalParticle_get_state(part) == XC_LOST_ON_EVEREST_COLL){
+            LocalParticle_set_state(part, XC_LOST_ON_EVEREST_CRYSTAL);
+        } else {
+            // We call the main Amorphous function for the leftover
+            everest->rescale_scattering = 1;
 #ifndef XCOLL_REFINE_ENERGY
-                calculate_scattering(everest, pc);
+            calculate_scattering(everest, pc);
 #endif
-                pc = Amorphous(everest, part, cg, pc, length - channeled_length, 1);
-            }
+            pc = Amorphous(everest, part, cg, pc, length - channeled_length, 1);
         }
     }
 
     return pc;
 }
 
-#endif /* XCOLL_EVEREST_CHANNELING_H */
+#endif /* XCOLL_EVEREST_CHANNELLING_H */

xcoll/scattering_routines/everest/constants.h

@@ -50,7 +50,7 @@
     #define   XC_THERMAL_VIBRATIONS ( 0.075e-10 )
 #endif 
 
-// No idea what this represents physically...
+// Classical radius of electron [m]
 #if !defined( XC_CRADE )
     #define   XC_CRADE ( 2.817940285e-15 )
 #endif 

xcoll/scattering_routines/everest/crystal_parameters.h

@@ -19,7 +19,7 @@ void calculate_initial_angle(EverestData restrict everest, LocalParticle* part,
     double x_P = cg->x_P;
     double r   = sqrt((s-s_P)*(s-s_P) + (x-x_P)*(x-x_P));
     everest->r = r;
-    everest->t_I = R/fabs(R)*asin( (s-s_P)/r); // Tangent angle of the channeling planes (not neccecarly the same as xp)
+    everest->t_I = R/fabs(R)*asin( (s-s_P)/r); // Tangent angle of the channelling planes (not necessarily the same as xp)
 }
 
 
@@ -68,7 +68,7 @@ void calculate_opening_angle(EverestData restrict everest, LocalParticle* part,
         }
     }
 
-    // Opening angle of channeling trajectory
+    // Opening angle of channelling trajectory
     double s = LocalParticle_get_s(part);
     double x = LocalParticle_get_x(part);
     everest->t_P = acos(1 - ( (s_F-s)*(s_F-s) - (x_F-x)*(x_F-x) ) / (2*r*r) );
@@ -78,17 +78,17 @@ void calculate_opening_angle(EverestData restrict everest, LocalParticle* part,
 /*gpufun*/
 double _critical_angle0(EverestCollData restrict coll, double pc){
     // Define typical angles/probabilities for orientation 110
-    double eum   = coll->eum;
-    double eta   = coll->eta;
+    double eum = coll->eum;
+    double eta = coll->eta;
     return sqrt(2.e-9*eta*eum/pc); // Critical angle (rad) for straight crystals    // pc is actually beta pc
 }
 
 /*gpufun*/
 double _critical_radius(EverestCollData restrict coll, double pc){
     // Define typical angles/probabilities for orientation 110
-    double eum   = coll->eum;
-    double ai    = coll->ai;
-    double eta   = coll->eta;
+    double eum = coll->eum;
+    double ai  = coll->ai;
+    double eta = coll->eta;
     return pc/(2.e-6*sqrt(eta)*eum)*ai;  // Critical curvature radius [m]   // pc is actually beta pc
 }
 
@@ -96,7 +96,7 @@ double _critical_radius(EverestCollData restrict coll, double pc){
 double _critical_angle(EverestCollData restrict coll, double t_c0, double Rc_over_R){
     double t_c = 0;
     if (Rc_over_R <= 1.) {
-        // Otherwise no channeling possible
+        // Otherwise no channelling possible
         t_c = t_c0*(1 - Rc_over_R); // Critical angle for curved crystal
         if (coll->orient == 2) {
             t_c *= 0.98;
@@ -132,7 +132,7 @@ void calculate_VI_parameters(EverestData restrict everest, LocalParticle* part,
     double c2 = 5./3.;  // Fitting coefficient
     double c3 =  1.7;   // Fitting coefficient
     if (ratio > 1.) {
-        // no channeling possibile
+        // no channelling possibile
         Ang_avr = c1*t_c0*5.e-2/ratio;         // Average angle reflection
         Ang_rms = c3*0.42*t_c0*sin(1.4/ratio); // RMS scattering
         everest->Vcapt = 0.;                   // Probability of VC is zero

xcoll/scattering_routines/everest/everest.h

@@ -6,7 +6,10 @@
 #ifndef XCOLL_EVEREST_ENGINE_H
 #define XCOLL_EVEREST_ENGINE_H
 
-#define XCOLL_TRANSITION
+#define XCOLL_TRANSITION_VRCH
+#define XCOLL_TRANSITION_VRAM
+// #define XCOLL_TRANSITION_VRAM_OLD
+
 
 typedef struct EverestCollData_ {
     // Collimator properties
@@ -47,8 +50,10 @@ typedef struct EverestData_ {
     double prob_tail_c2;
     double prob_tail_c3;
     double prob_tail_c4;
-    double energy_loss;
-    double energy_loss_tail;
+    double energy_loss_m;
+    double energy_loss_xi_m;
+    double energy_loss_most_probable_m;
+    double energy_loss_tail_m;
     // Crystal data
     double rescale_scattering;
     double t_c;

xcoll/scattering_routines/everest/everest.py

@@ -24,10 +24,11 @@ class EverestEngine(xt.BeamElement):
         _pkg_root.joinpath('scattering_routines','everest','constants.h'),
         _pkg_root.joinpath('scattering_routines','everest','everest.h'),
         _pkg_root.joinpath('scattering_routines','everest','properties.h'),
+        _pkg_root.joinpath('scattering_routines','everest','ionisation_loss.h'),
         _pkg_root.joinpath('scattering_routines','everest','multiple_coulomb_scattering.h'),
         _pkg_root.joinpath('scattering_routines','everest','nuclear_interaction.h'),
         _pkg_root.joinpath('scattering_routines','everest','crystal_parameters.h'),
         _pkg_root.joinpath('scattering_routines','everest','amorphous.h'),
         _pkg_root.joinpath('scattering_routines','everest','jaw.h'),
-        _pkg_root.joinpath('scattering_routines','everest','channeling.h')
+        _pkg_root.joinpath('scattering_routines','everest','channelling.h')
     ]

xcoll/scattering_routines/everest/ionisation_loss.h

@@ -0,0 +1,141 @@
+// copyright ############################### #
+// This file is part of the Xcoll package.   #
+// Copyright (c) CERN, 2025.                 #
+// ######################################### #
+
+#ifndef XCOLL_EVEREST_IONLOSS_H
+#define XCOLL_EVEREST_IONLOSS_H
+#include <stdlib.h>
+#include <math.h>
+#include <stdio.h>
+
+/*gpufun*/
+void calculate_ionisation_properties(EverestData restrict everest, double pc) {
+    if (everest->coll->only_mcs){   // TODO: this should be done smarter
+        return;
+    }
+
+    // Material properties
+    double const exenergy = everest->coll->exenergy*1.0e3; // [MeV]
+    double const rho      = everest->coll->rho;
+    double const anuc     = everest->coll->anuc;
+    double const zatom    = everest->coll->zatom;
+
+    // Energy variables
+    double momentum = pc*1.0e3;   // [MeV]
+    double energy   = sqrt(pow(momentum, 2.) + pow(XC_PROTON_MASS, 2.)); // [MeV]
+    double gammar   = energy/XC_PROTON_MASS;
+    double betar    = momentum/energy;
+    double bgr      = betar*gammar;
+    double mep      = XC_ELECTRON_MASS/XC_PROTON_MASS;  // Electron/proton
+
+    // tmax is max energy loss from kinematics
+    // mep = mass_electron / mass_beam
+    double tmax = 2.*XC_ELECTRON_MASS*pow(bgr, 2.)/ (1. + 2.*gammar*mep + pow(mep, 2.));  // [MeV]
+    double plen = sqrt(rho*zatom/anuc)*28.816e-6; // [MeV]
+
+    // TODO: Bete-Bloch needs to be adapted for high energy (more loss due to delta ray radiation)
+    //       and low energy (nuclear scattering)
+    // TODO: should scale with z^2 (incoming charge)
+    double BB_fac = XC_BETHE_BLOCH/2*zatom/anuc/betar/betar;  // [MeV*cm^2/g]
+    everest->energy_loss_xi_m = BB_fac*rho*1.0e-1; // [GeV/m]   xi per meter
+    double e_ionisation = log(2.*XC_ELECTRON_MASS*bgr*bgr/exenergy);
+    double density = 2*log(plen/exenergy) + 2*log(bgr) - 1;
+    everest->energy_loss_m = e_ionisation + log(tmax/exenergy) - 2*pow(betar, 2.) - density;
+    everest->energy_loss_m *= everest->energy_loss_xi_m; // [GeV/m]
+
+    // Straggling: energy loss is Gaussian for thick absorbers (TODO: it's Landau-Vavilov for thin absorbers when eps << Tmax)
+    // TODO: does it come naturally from variations in trajectory (when using NewGeometry)?
+    everest->energy_loss_most_probable_m = e_ionisation - log(exenergy*1.e-3) + 0.194 - pow(betar, 2.) - density;
+    everest->energy_loss_most_probable_m *= everest->energy_loss_xi_m; // [GeV/m]   missing factor xi ln xi
+
+    everest->energy_loss_tail_m = e_ionisation+ log(tmax/exenergy) - 2*pow(betar, 2.) - density;  // Bethe-Bloch
+    everest->energy_loss_tail_m += 2*tmax*tmax/8/energy/energy;
+    everest->energy_loss_tail_m *= everest->energy_loss_xi_m; // [GeV/m]
+
+    double Tt = everest->energy_loss_m*1.0e3 + 8*everest->energy_loss_xi_m*1e3; // [MeV/m]
+
+    // Calculate different coefficients for terms in dz (length) to get the tail probability
+    double const prob_factor = everest->energy_loss_xi_m*1.e3; // [MeV/m]
+    everest->prob_tail_c1 = prob_factor / Tt;
+    everest->prob_tail_c2 = prob_factor * (
+                        2*tmax/(4.*pow(energy, 2.)) - 1/tmax
+                        - log(tmax/Tt)*pow(betar,2.)/tmax
+                   );  // * dz
+    everest->prob_tail_c3 = prob_factor * pow(betar,2.)/tmax;   // * dz * log(dz)
+    everest->prob_tail_c4 = -prob_factor * Tt/(2.*pow(energy, 2.));  // * dz * dz
+}
+
+
+/*gpufun*/
+double calcionloss(EverestData restrict everest, LocalParticle* part, double ionisation_length, double pc, double scale_factor) {
+
+#ifdef XCOLL_REFINE_ENERGY
+    calculate_ionisation_properties(everest, pc);
+#endif
+
+    double ionisation_loss;
+    InteractionRecordData record = everest->coll->record;
+    RecordIndex record_index     = everest->coll->record_index;
+    int8_t sc = everest->coll->record_scatterings;
+
+    double mp = LocalParticle_get_mass0(part)/1.e9;  // [GeV]   TODO: update when allowing other than protons
+    double kinetic_energy = sqrt(pow(pc, 2.) + pow(mp, 2.)) - mp;
+    int8_t dead = 0;
+    double cutoff = 1.e-6; // Lower cutoff of 1keV
+    double new_pc = 0;
+    double new_pc_2 = 0;
+
+    double prob_tail = everest->prob_tail_c1 + everest->prob_tail_c2 * ionisation_length
+                     + everest->prob_tail_c3 * ionisation_length * log(ionisation_length)
+                     + everest->prob_tail_c4 * ionisation_length * ionisation_length;
+
+    double xi = ionisation_length*everest->energy_loss_xi_m;
+    if (RandomUniform_generate(part) < prob_tail) {
+        ionisation_loss = ionisation_length*everest->energy_loss_tail_m;
+    } else {
+        ionisation_loss = ionisation_length*everest->energy_loss_most_probable_m;
+        ionisation_loss += xi*log(xi);
+    }
+
+    // Straggling: energy loss is double Gaussian-like for thick absorbers (TODO: it's Landau-Vavilov for thin absorbers when xi << Tmax)
+    double ran1 = RandomNormal_generate(part);
+    double ran2 = RandomUniform_generate(part);
+    // Sample from two Gaussians, to mimic the fat tail of the Landau distribution
+    if (ran2 >= 0.8) {
+        ionisation_loss += 3*xi + ran1*xi*3.39729; // 3.39729 = 4/sqrt(2ln2)
+    } else {
+        ionisation_loss += xi + ran1*xi*1.69864; // 1.69864 = 2/sqrt(2ln2)
+    }
+    if (ionisation_loss < 1.e-12) {
+        ionisation_loss = 0;
+    } else {
+        ionisation_loss *= scale_factor;
+    }
+
+    if (ionisation_loss > kinetic_energy - cutoff) {
+        // All energy lost due to ionisation!
+        dead = 1;
+    } else {
+        new_pc_2 = pow(kinetic_energy - ionisation_loss + mp, 2.) - pow(mp, 2.);
+        if (new_pc_2 <= 1.e-12 || new_pc_2 != new_pc_2){
+            // Rounding error. Kill particle to avoid NaN  (a != a is true only for NaN)
+            dead = 1;
+        } else {
+            new_pc = sqrt(new_pc_2);
+            if (new_pc != new_pc){
+                // NaN
+                dead = 1;
+            }
+        }
+    }
+    if (dead) {
+        if (sc) InteractionRecordData_log(record, record_index, part, XC_ABSORBED);
+        LocalParticle_set_state(part, XC_LOST_ON_EVEREST_COLL);
+        return cutoff;
+    } else {
+        return new_pc;
+    }
+}
+
+#endif /* XCOLL_EVEREST_IONLOSS_H */

xcoll/scattering_routines/everest/jaw.h

@@ -10,56 +10,51 @@
 
 
 /*gpufun*/
-double jaw(EverestData restrict everest, LocalParticle* part, double p, double length, int edge_check) {
+double jaw(EverestData restrict everest, LocalParticle* part, double pc, double length, int edge_check) {
     if (LocalParticle_get_state(part) < 1){
         // Do nothing if already absorbed
-        return p;
+        return pc;
     }
 
-    double rlen = length;
-    double s0 = LocalParticle_get_s(part);
-    p /= 1e9;   // Energy (not momentum) in GeV
+    pc /= 1.e9; // [GeV]
 
     if (everest->coll->only_mcs) {
-        mcs(everest, part, rlen, p, edge_check);
+        // TODO: ionisation loss should also be calculated when only_mcs
+        mcs(everest, part, length, pc, edge_check);
 
     } else {
-        // Do a step for a point-like interaction.
-        // Get monte-carlo interaction length.
+        double rlen = length;
+        double s0 = LocalParticle_get_s(part);
         while (1) {
-            calculate_ionisation_properties(everest, p);
+            // Length of the step until nuclear interaction
             double length_step = everest->xintl*RandomExponential_generate(part);
 
-            // If the monte-carlo interaction length is longer than the remaining
-            // length, then put it to the remaining length, do mcs and return.
             if (length_step > rlen) {
-                mcs(everest, part, rlen, p, edge_check);
+                // Length to nuclear interaction is longer than remaining: MCS to end and exit collimator
+                mcs(everest, part, rlen, pc, edge_check);
                 break;
             }
 
-            // Otherwise do multi-coulomb scattering.
-            mcs(everest, part, length_step, p, edge_check);
-
-            if(LocalParticle_get_x(part) <= 0) {
-                // PARTICLE LEFT COLLIMATOR BEFORE ITS END.
+            mcs(everest, part, length_step, pc, edge_check);
+            if (LocalParticle_get_state(part) < 1 || (edge_check && LocalParticle_get_x(part) <= 0)){
+                // Particle lost all energy due to ionisation, or left the collimator
                 break;
             }
 
-            p = nuclear_interaction(everest, part, p);
+            pc = nuclear_interaction(everest, part, pc);
             if (LocalParticle_get_state(part) < 1){
-                // PARTICLE WAS ABSORBED INSIDE COLLIMATOR DURING MCS.
+                // Particle was absorbed
                 break;
             }
 
             // Calculate the remaining interaction length and close the iteration loop.
             rlen = rlen - length_step;
         }
-        // TODO: ionisation loss should also be calculated when only_mcs
-        double m_dpodx = calcionloss(everest, part, rlen);  // DM routine to include tail // TODO: should not be rlen but s after updating
-        double s = LocalParticle_get_s(part) - s0;
-        p = p-m_dpodx*s; // TODO: This is correct: ionisation loss is only calculated and applied at end of while (break)
+        calculate_ionisation_properties(everest, pc);
+        double ionisation_length = LocalParticle_get_s(part) - s0;
+        pc = calcionloss(everest, part, ionisation_length, pc, 1);
     }
-    return p*1e9;  // Back to eV
+    return pc*1e9;  // Back to eV
 }
 
 #endif /* XCOLL_EVEREST_JAW_H */

xcoll/scattering_routines/everest/materials.py

@@ -37,6 +37,8 @@ class GeneralMaterial(xo.HybridClass):
         '_only_mcs':                xo.Int8
     }
 
+    _depends_on = [xo.Float64]
+
     def __init__(self, **kwargs):
         if '_xobject' not in kwargs:
             kwargs.setdefault('hcut', 0.02)