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

xcoll/rf_sweep.py

@@ -1,6 +1,6 @@
 # copyright ############################### #
 # This file is part of the Xcoll Package.   #
-# Copyright (c) CERN, 2023.                 #
+# Copyright (c) CERN, 2024.                 #
 # ######################################### #
 
 import numpy as np

xcoll/scattering_routines/everest/amorphous.h

@@ -0,0 +1,239 @@
+// copyright ############################### #
+// This file is part of the Xcoll Package.   #
+// Copyright (c) CERN, 2023.                 #
+// ######################################### #
+
+#ifndef XCOLL_EVEREST_AMORPHOUS_H
+#define XCOLL_EVEREST_AMORPHOUS_H
+#include <math.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+
+/*gpufun*/
+void volume_reflection(EverestData restrict everest, LocalParticle* part, int8_t transition) {
+
+    InteractionRecordData record = everest->coll->record;
+    RecordIndex record_index     = everest->coll->record_index;
+    int8_t sc = everest->coll->record_scatterings;
+    int64_t i_slot;
+
+
+    double Ang_avr = everest->Ang_avr;
+    double Ang_rms = everest->Ang_rms;
+
+    if (transition == XC_VOLUME_REFLECTION_TRANS_CH){
+        // We are in transition from CH to VR
+        double xp = LocalParticle_get_xp(part);
+        // TODO: we believe the original 0.45 comes from the 0.9 saturation factor, so we changed it to 0.5
+        Ang_avr *= 0.5*((xp - everest->t_I)/everest->t_c + 1);
+        Ang_rms  = 0;   // TODO: why does transition to CH not use any spread?
+        if (sc) i_slot = InteractionRecordData_log(record, record_index, part, XC_VOLUME_REFLECTION_TRANS_CH);
+
+    } else if (transition == XC_VOLUME_REFLECTION_TRANS_MCS){
+        // We are in transition from VR to MCS
+//         double t_c = everest->t_c;
+//         double t_P = everest->t_P;
+//         double xp_rel = LocalParticle_get_xp(part) - everest->t_I;
+//         // TODO: where does 3 come from
+//         Ang_rms *= -3.*(xp_rel-t_P)/(2.*t_c); // TODO: why no random number?
+        Ang_rms *= RandomNormal_generate(part);
+        if (sc) i_slot = InteractionRecordData_log(record, record_index, part, XC_VOLUME_REFLECTION_TRANS_MCS);
+
+    } else {
+        Ang_rms *= RandomNormal_generate(part);
+        if (sc) i_slot = InteractionRecordData_log(record, record_index, part, XC_VOLUME_REFLECTION);
+    }
+
+    double t_VR = Ang_avr + Ang_rms;
+    LocalParticle_add_to_xp(part, t_VR);
+    if (sc) InteractionRecordData_log_child(record, i_slot, part, 0);
+}
+
+
+// Amorphous transport is just Multiple Coulomb scattering
+/*gpufun*/
+double amorphous_transport(EverestData restrict everest, LocalParticle* part, double pc, double length, int8_t transition) {
+
+    InteractionRecordData record = everest->coll->record;
+    RecordIndex record_index     = everest->coll->record_index;
+    int8_t sc = everest->coll->record_scatterings;
+    int64_t i_slot;
+
+    // Accumulated effect of mcs on the angles (with initial energy)
+    // TODO: pc is energy
+    // TODO: missing factor (1 + 0.038*log( L / dlri) )  ( *Z if not protons)
+    double dya = (13.6/pc)*sqrt(length/everest->coll->dlri)*1.0e-3; // RMS of coloumb scattering MCS (rad)
+    double kxmcs, kymcs;
+
+    if (transition == XC_MULTIPLE_COULOMB_TRANS_VR){
+        // Transition MCS
+        if (sc) i_slot = InteractionRecordData_log(record, record_index, part, XC_MULTIPLE_COULOMB_TRANS_VR);
+//         double xp_rel = LocalParticle_get_xp(part) - everest->t_I;
+//         double t_P = everest->t_P;
+//         double t_c = everest->t_c;
+//         dya *= 1 - (xp_rel-t_P)/(2.*t_c);
+    } else {
+        // Normal MCS
+        if (sc) i_slot = InteractionRecordData_log(record, record_index, part, XC_MULTIPLE_COULOMB_SCATTERING);
+    }
+    kxmcs = dya*RandomNormal_generate(part);
+    kymcs = dya*RandomNormal_generate(part);
+
+    // Transport of Multiple Coulomb Scattering
+    Drift_single_particle_4d(part, length);
+
+    // Energy lost because of ionisation process[GeV]
+    double energy_loss = calcionloss(everest, part, length);
+    pc  = pc - energy_loss*length;
+
+    // Store new angles
+    LocalParticle_add_to_xp_yp(part, kxmcs, kymcs);
+
+    // Finally log particle at end of mcs
+    if (sc) InteractionRecordData_log_child(record, i_slot, part, length);
+
+    return pc;
+}
+
+double Channel(EverestData restrict everest, LocalParticle* part, CrystalGeometry restrict cg, double pc, double length);
+
+/*gpufun*/
+double Amorphous(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;
+
+    calculate_initial_angle(everest, part, cg);
+
+    // -----------------------------------------------
+    // Calculate longitudinal position where we go out
+    // -----------------------------------------------
+    // Assumption: crystal bends away from beam (this does not work when crystal bends towards beam)
+    // All s are absolute in the collimator frame
+    double R = cg->bending_radius;
+    double t = cg->bending_angle;
+    double d = cg->width;
+    double s  = LocalParticle_get_s(part);
+    double x  = LocalParticle_get_x(part);
+    double xp = LocalParticle_get_xp(part);
+    // We either exit the crystal at the exit face
+    double s1 = (R - x + s*xp) / (xp + cos(t)/sin(t) );
+    if (s1 < s) {s1 = 1e10;}
+    // or the larger bend
+    double dd = (R - x + s*xp) / (1 + xp*xp);
+    double s2 = dd*xp + sqrt(R*R / (1 + xp*xp) * dd*dd);
+    if (s2 < s) {s2 = 1e10;}
+    // or the smaller bend (which potentially has two solutions, in case the particle enters again before the exit face)
+    double s3 = dd*xp - sqrt( (R-d)*(R-d) / (1 + xp*xp) * dd*dd);
+    if (s3 < s) {s3 = 1e10;}
+    // whichever comes first after the current position.
+    // This gives us an "exit length" \with respect to the current position
+    double exit_point  = fmin(fmin(s1, s2), s3);
+    double length_exit = fmin(exit_point - s, length);
+
+    // ----------------------------------------------------
+    // Calculate longitudinal length of nuclear interaction
+    // ----------------------------------------------------
+    double length_nucl = everest->coll->collnt*RandomExponential_generate(part);
+
+    // --------------------------------------------------------------
+    // Calculate longitudinal length of volume interaction (VR or VC)
+    // --------------------------------------------------------------
+    // This happens when the particle is tangential to the crystal planes.
+    // The (straight) trajectory until the point of reflection is r sin(xp - t_I),
+    // hence the longitudinal length is r sin(xp - miscut) cos xp
+    double length_VI = everest->r * sin(xp - everest->t_I) * cos(xp);
+    // If length_VI is negative, VI is not possible, so set to a big value
+    if (length_VI < 0) {length_VI = 1e10;}
+    // Calculate extra length to transition region between VR and AM
+    double length_VR_trans = everest->r * sin(xp - everest->t_I - 2.*everest->t_c) * cos(xp - 2.*everest->t_c);
+    if (length_VR_trans < 0) {length_VR_trans = 1e10;}
+
+    // ------------------------------------------------------------------------
+    // Compare the 3 lengths: the first one encountered is what will be applied
+    // ------------------------------------------------------------------------
+    if (length_VI <= fmin(length_nucl, length_exit)){
+        // MCS to volume interaction
+        pc = amorphous_transport(everest, part, pc, length_VI, 0);
+#ifdef XCOLL_REFINE_ENERGY
+        calculate_VI_parameters(everest, part, pc);
+#endif
+        // Are we reflecting or captured?
+        if (RandomUniform_generate(part) > everest->Vcapt) {
+            // Volume Reflection
+            volume_reflection(everest, part, 0);
+            // We call the main Amorphous function for the leftover
+            pc = Amorphous(everest, part, cg, pc, length - length_VI);
+
+        } else {
+            // Volume Capture
+            if (sc) InteractionRecordData_log(record, record_index, part, XC_VOLUME_CAPTURE);
+            // We call the main Channel function for the leftover
+            pc = Channel(everest, part, cg, pc, length - length_VI);
+        }
+
+#ifdef XCOLL_TRANSITION
+    } else if (length_VR_trans <= fmin(length_nucl, length_exit)){
+        // Transition region between VR and AM for t_P < xp - tI < t_P + 2t_c
+#ifdef XCOLL_REFINE_ENERGY
+        calculate_critical_angle(everest, part, cg, pc);
+#endif
+        double xp_rel = xp - everest->t_I;
+        double t_P = everest->t_P;
+        double t_c = everest->t_c;
+        double prob_MCS = (xp_rel - t_P) / (2*t_c);
+        if (RandomUniform_generate(part) > prob_MCS){
+            // We are on the VR side
+            pc = amorphous_transport(everest, part, pc, length_VR_trans, 0);
+            volume_reflection(everest, part, XC_VOLUME_REFLECTION_TRANS_MCS);
+            pc = amorphous_transport(everest, part, pc, length - length_VR_trans, 0);
+        } else {
+            // We are on the AM side
+            pc = amorphous_transport(everest, part, pc, length, XC_MULTIPLE_COULOMB_TRANS_VR);
+        }
+#endif
+
+    } else if (length_nucl < length_exit) {
+        // MCS to nuclear interaction
+        pc = amorphous_transport(everest, part, pc, length_nucl, 0);
+        // interact
+        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
+            pc = Amorphous(everest, part, cg, pc, length - length_nucl);
+        }
+
+    } else {
+        // Exit crystal
+        // MCS to exit point
+        pc = amorphous_transport(everest, part, pc, length_exit, 0);
+        // Now drift the remaining
+        // However, if we have exited at s3, and we encounter s4 before s2, we reenter:
+        double s4 = dd*xp + sqrt( (R-d)*(R-d) / (1 + xp*xp) * dd*dd);  // second solution for smaller bend
+        if (s3 < fmin(s1, s2) && s4 < s2){
+            // We drift until re-entry
+            Drift_single_particle_4d(part, s4 - exit_point);
+            // We call the main Amorphous function for the leftover
+            pc = Amorphous(everest, part, cg, pc, length - length_exit - s4 + exit_point);
+        } else {
+            // Drift leftover out of the crystal
+            if (everest->coll->record_touches){
+                InteractionRecordData_log(record, record_index, part, XC_EXIT_JAW);
+            }
+            Drift_single_particle_4d(part, length - length_exit);
+        }
+    }
+
+    return pc;
+}
+
+#endif /* XCOLL_EVEREST_AMORPHOUS_H */

xcoll/scattering_routines/everest/channeling.h

@@ -0,0 +1,245 @@
+// copyright ############################### #
+// This file is part of the Xcoll Package.   #
+// Copyright (c) CERN, 2023.                 #
+// ######################################### #
+
+#ifndef XCOLL_EVEREST_CHANNELING_H
+#define XCOLL_EVEREST_CHANNELING_H
+#include <math.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+
+// Convention:
+//       L: length of curved trajectory
+//       s: longitudinal coordinate (in collimator frame)  -  projection of curved trajectory
+//       t: opening angle of curve ('t' for theta)
+//       r: radius from position to bending centre (including t_I):  L = t*r
+
+
+/*gpufun*/
+double channeling_average_density(EverestData restrict everest, CrystalGeometry restrict cg, LocalParticle* part, double pc) {
+
+    // Material properties
+    double const anuc = everest->coll->anuc;
+    double const rho  = everest->coll->rho;
+    double const eum  = everest->coll->eum;
+
+    double bend_r = cg->bending_radius;
+    double ratio  = everest->Rc_over_R;
+
+    //Rescale the total and inelastic cross-section accordigly to the average density seen
+    double x_i = LocalParticle_get_x(part);
+    double xp  = LocalParticle_get_xp(part);
+    int np     = x_i/XC_PLANE_DISTANCE;          //Calculate in which crystalline plane the particle enters
+    x_i       -= (np + 0.5)*XC_PLANE_DISTANCE;   //Rescale the incoming x to the middle of the crystalline plane
+
+    double pv   = pow(pc, 2.)/sqrt(pow(pc, 2.) + pow(XC_PROTON_MASS*1.0e-3, 2.))*1.0e9; //Calculate pv=P/E   TODO: this is beta?
+    double Ueff = eum*4.*pow(x_i/XC_PLANE_DISTANCE, 2.) + pv*x_i/bend_r; //Calculate effective potential
+    double Et   = pv*pow(xp, 2.)/2. + Ueff;       //Calculate transverse energy
+    double Ec   = eum*pow(1. - ratio, 2.);         //Calculate critical energy in bent crystals
+
+    //To avoid negative Et
+    double xminU = -pow(XC_PLANE_DISTANCE, 2.)*pc*1.0e9/(8.*eum*bend_r);
+    double Umin  = fabs(eum*4.*pow(xminU/XC_PLANE_DISTANCE, 2.) + pv*xminU/bend_r);
+    Et    = Et + Umin;
+    Ec    = Ec + Umin;
+
+    //Calculate min e max of the trajectory between crystalline planes
+    double x_min = -0.5*XC_PLANE_DISTANCE*ratio - 0.5*XC_PLANE_DISTANCE*sqrt(Et/Ec);
+    double x_max = -0.5*XC_PLANE_DISTANCE*ratio + 0.5*XC_PLANE_DISTANCE*sqrt(Et/Ec);
+
+    //Change ref. frame and go back with 0 on the crystalline plane on the left
+    x_min = x_min - XC_PLANE_DISTANCE/2.;
+    x_max = x_max - XC_PLANE_DISTANCE/2.;
+
+    //Calculate the "normal density" in m^-3
+    double N_am  = rho*XC_AVOGADRO*1.0e6/anuc;
+
+    //Calculate atomic density at min and max of the trajectory oscillation
+    // erf returns the error function of complex argument
+    double rho_max = erf(x_max/sqrt(2*pow(XC_THERMAL_VIBRATIONS, 2.)));
+    rho_max       -= erf((XC_PLANE_DISTANCE-x_max)/sqrt(2*pow(XC_THERMAL_VIBRATIONS, 2.)));
+    rho_max       *= N_am*XC_PLANE_DISTANCE/2.;
+    double rho_min = erf(x_min/sqrt(2*pow(XC_THERMAL_VIBRATIONS, 2.)));
+    rho_min       -= erf((XC_PLANE_DISTANCE-x_min)/sqrt(2*pow(XC_THERMAL_VIBRATIONS, 2.)));
+    rho_min       *= N_am*XC_PLANE_DISTANCE/2.;
+
+    //"zero-approximation" of average nuclear density seen along the trajectory
+    double avrrho  = (rho_max - rho_min)/(x_max - x_min);
+    avrrho  = 2.*avrrho/N_am;
+
+    return avrrho;
+}
+
+
+/*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)
+    //             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
+    //             In practice: we drift from start to end, but overwrite the angle afterwards
+    // TODO: why does channeling only have 50% energy loss?
+
+    double* result = (double*)malloc(2 * sizeof(double));
+
+    InteractionRecordData record = everest->coll->record;
+    RecordIndex record_index     = everest->coll->record_index;
+    int8_t sc = everest->coll->record_scatterings;
+
+    // First log particle at start of channeling
+    int64_t i_slot;
+    if (sc) i_slot = InteractionRecordData_log(record, record_index, part, XC_CHANNELING);
+
+    // Do channeling.
+    // 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)
+    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
+    Drift_single_particle_4d(part, drift_length);
+    // In reality,the particle oscillates horizontally between the planes while channeling.
+    // 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
+
+    // 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);
+    // 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
+    if (sc) InteractionRecordData_log_child(record, i_slot, part, drift_length);
+
+    result[0] = drift_length;
+    result[1] = pc;
+    return result;
+}
+
+
+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;
+
+    calculate_initial_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_REFINE_ENERGY
+        calculate_VI_parameters(everest, part, pc);
+#endif
+        volume_reflection(everest, part, XC_VOLUME_REFLECTION_TRANS_CH);
+#endif
+        pc = Amorphous(everest, part, cg, pc, length);
+
+    } 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;
+        }
+        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);
+            // Drift leftover outside of crystal
+            if (everest->coll->record_touches){
+                InteractionRecordData_log(record, record_index, part, XC_EXIT_JAW);
+            }
+            Drift_single_particle_4d(part, length - channeled_length);
+
+        } 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);
+
+        } 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);
+#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;
+#ifndef XCOLL_REFINE_ENERGY
+                calculate_scattering(everest, pc);
+#endif
+                pc = Amorphous(everest, part, cg, pc, length - channeled_length);
+            }
+        }
+    }
+
+    return pc;
+}
+
+#endif /* XCOLL_EVEREST_CHANNELING_H */

xcoll/scattering_routines/everest/crystal_parameters.h

@@ -0,0 +1,137 @@
+// copyright ############################### #
+// This file is part of the Xcoll Package.   #
+// Copyright (c) CERN, 2023.                 #
+// ######################################### #
+
+#ifndef XCOLL_EVEREST_CRYSTAL_PARAMETERS_H
+#define XCOLL_EVEREST_CRYSTAL_PARAMETERS_H
+#include <math.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+
+/*gpufun*/
+void calculate_initial_angle(EverestData restrict everest, LocalParticle* part, CrystalGeometry restrict cg) {
+    double R = cg->bending_radius;
+    double s = LocalParticle_get_s(part);
+    double x = LocalParticle_get_x(part);
+    double s_P = cg->s_P;
+    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)
+}
+
+
+/*gpufun*/
+void calculate_opening_angle(EverestData restrict everest, LocalParticle* part, CrystalGeometry restrict cg) {
+    double t    = cg->bending_angle;
+    double xd   = cg->width;
+    double R    = cg->bending_radius;
+    double sinp = sin(cg->miscut_angle);
+    double cosp = cos(cg->miscut_angle);
+
+    // Radius from starting point to miscut centre
+    double r = everest->r;
+    // Intersection with exit face
+    double bb = R/2. * sin(2.*t) * (1 - cosp - tan(t)*sinp);
+    double s_F = bb + sqrt(bb*bb - tan(t)*sin(2.*t)*(R*R*(1-cosp) - r*r/2.));
+    double x_F = R - s_F/tan(t);
+
+    // We could intersect with the upper (positive miscut) or lower bend (negative miscut) before the exit face
+    // Distance between bending centre and miscut centre:
+    double d = R*sqrt(2*(1-cosp));
+    if (cg->miscut_angle > 0){
+        // Check if intersection with upper bend R-xd is possible
+        double Rb = R-xd;
+        if (d > fabs(r - Rb)){
+            double st_UB = (r*r - Rb*Rb)/(2*d);
+            double xt_UB = -sqrt(r*r/2. + Rb*Rb/2. - st_UB*st_UB - d*d/4.);
+            double s_UB  = (st_UB/d - 0.5)*R*sinp - xt_UB/d*R*(1-cosp);
+            if (s_F > s_UB){
+                // Upper bend encountered before exit face
+                s_F = s_UB;
+                x_F = (st_UB/d + 0.5)*R*(1-cosp) + xt_UB/d*R*sinp + R*cosp;
+            }
+        }
+    } else {
+        // Check if intersection with lower bend R is possible
+        if (d > fabs(R - r)){
+            double st_LB = (R*R - r*r)/(2*d);
+            double xt_LB = -sqrt(r*r/2. + R*R/2. - st_LB*st_LB - d*d/4.);
+            double s_LB  = -(st_LB/d + 0.5)*R*sinp + xt_LB/d*R*(1-cosp);
+            if (s_F > s_LB){
+                // Lower bend encountered before exit face
+                s_F = s_LB;
+                x_F = -(st_LB/d - 0.5)*R*(1-cosp) - xt_LB/d*R*sinp + R*cosp;
+            }
+        }
+    }
+
+    // Opening angle of channeling 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) );
+}
+
+
+/*gpufun*/
+void calculate_critical_angle(EverestData restrict everest, LocalParticle* part, CrystalGeometry restrict cg, double pc) {
+    // Define typical angles/probabilities for orientation 110
+    double eum   = everest->coll->eum;
+    double ai    = everest->coll->ai;
+    double eta   = everest->coll->eta;
+    double t_c0  = sqrt(2.e-9*eta*eum/pc); // Critical angle (rad) for straight crystals   // pc is actually beta pc
+    double Rcrit = pc/(2.e-6*sqrt(eta)*eum)*ai;  // Critical curvature radius [m]          // pc is actually beta pc
+
+    // If Rcritical > R => no channeling is possible (Rc_over_R > 1)
+    everest->Rc_over_R = Rcrit / fabs(cg->bending_radius);
+    everest->t_c0 = t_c0;
+    everest->t_c  = t_c0*(1 - everest->Rc_over_R); // Critical angle for curved crystal
+
+    if (everest->coll->orient == 2) {
+        everest->t_c *= 0.98;
+    }
+}
+
+
+/*gpufun*/
+void calculate_VI_parameters(EverestData restrict everest, LocalParticle* part, double pc) {
+
+    double ratio = everest->Rc_over_R;
+    double t_c0  = everest->t_c0;
+
+    // Correction by sasha drozdin/armen    // TODO: pc = energy
+    // K=0.0007 is taken based on simulations using CATCH.f (V.Biryukov)
+    // TODO: From the paper (arXiv:0808.1486, eq (18), (34)) it seems the power of E should be 0.25
+    // Typo in Daniele's thesis in 3.25 (E^0.2 instead of 1/E^0.2)
+    everest->Vcapt = 7.e-4*(1./ratio - 0.7)/pow(pc, 0.2);
+
+    double Ang_rms, Ang_avr;
+    double c1 = -3./2.;   // Fitting coefficient
+    double c2 = 5./3.;  // Fitting coefficient
+    double c3 =  1.7;   // Fitting coefficient
+    if (ratio > 1.) {
+        // no channeling 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
+    } else if (ratio > 1./3.) {
+        // Strongly bent crystal
+        Ang_avr = c1*t_c0*(0.1972/ratio - 0.1472);        // Average angle reflection
+        Ang_rms = c3*0.42*t_c0*sin(0.4713/ratio + 0.85);  // RMS scattering
+    } else {
+        // Rcrit << R
+        Ang_avr = c1*t_c0*(1. - c2*ratio);     // Average angle for VR
+        Ang_rms = c3*t_c0*ratio;               // RMS scattering
+    }
+    if (everest->coll->orient == 2) {
+        Ang_avr = Ang_avr*0.93;
+        Ang_rms = Ang_rms*1.05;
+    }
+
+    everest->Ang_rms = Ang_rms;
+    everest->Ang_avr = Ang_avr;
+}
+
+#endif /* XCOLL_EVEREST_CRYSTAL_PARAMETERS_H */