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

xcoll/scattering_routines/everest/everest.h

@@ -1,34 +1,20 @@
 // copyright ############################### #
 // This file is part of the Xcoll Package.   #
-// Copyright (c) CERN, 2023.                 #
+// Copyright (c) CERN, 2024.                 #
 // ######################################### #
 
 #ifndef XCOLL_EVEREST_ENGINE_H
 #define XCOLL_EVEREST_ENGINE_H
 
+#define XCOLL_TRANSITION
 
 typedef struct EverestCollData_ {
     // Collimator properties
-    double aperture;   // TODO: This should go out, as it's geometry and that should not be used in Everest scattering
-    double offset;     // TODO: This should go out, as it's geometry and that should not be used in Everest scattering
-    double tilt_L;     // TODO: This should go out, as it's geometry and that should not be used in Everest scattering
-    double tilt_R;     // TODO: This should go out, as it's geometry and that should not be used in Everest scattering
-    double side;       // TODO: This should go out, as it's geometry and that should not be used in Everest scattering
     RandomRutherfordData restrict rng;
-    CollimatorImpactsData record;
+    InteractionRecordData record;
     RecordIndex record_index;
-    // Crystal properties
-    double bend_r;
-    double bend_ang;
-    double tilt;
-    double amorphous_layer;
-    double xdim;
-    double ydim;
-    int8_t orient;
-    double miscut;
-    double s_P;
-    double x_P;
-    double t_VImax;
+    int8_t record_scatterings;
+    int8_t record_touches;
     // Material properties
     // TODO: can we use pointers for the MaterialData? It then gets a bit difficult to read them, ie *coll->exenergy
     double exenergy;
@@ -43,6 +29,8 @@ typedef struct EverestCollData_ {
     double ai;
     double eum;
     double collnt;
+    double eta;
+    int8_t orient;
     int8_t only_mcs;
 } EverestCollData_;
 typedef EverestCollData_ *EverestCollData;
@@ -62,6 +50,7 @@ typedef struct EverestData_ {
     double prob_tail_c4;
     double energy_loss;
     double energy_loss_tail;
+    // Crystal data
     double rescale_scattering;
     double t_c;
     double t_c0;
@@ -90,17 +79,6 @@ void Drift_single_particle_4d(LocalParticle* part, double length){
     LocalParticle_set_zeta(part, zeta);
 }
 
-/*gpufun*/
-double YRotation_single_particle_rotate_only(LocalParticle* part, double s, double angle){
-    double x   = LocalParticle_get_x(part);
-    double rpp = LocalParticle_get_rpp(part);
-    double sin_y = sin(angle);
-    double cos_y = cos(angle);
-    LocalParticle_set_x(part, x*cos_y - s*sin_y);
-    LocalParticle_add_to_px(part,-angle/rpp);
-    return x*sin_y + s*cos_y;  // new s
-}
-
 /*gpukern*/
 void RandomRutherford_set_by_xcoll_material(RandomRutherfordData ran, GeneralMaterialData material){
     double const zatom    = GeneralMaterialData_get_Z(material);

xcoll/scattering_routines/everest/everest.py

@@ -1,30 +1,33 @@
 # copyright ############################### #
 # This file is part of the Xcoll Package.   #
-# Copyright (c) CERN, 2023.                 #
+# Copyright (c) CERN, 2024.                 #
 # ######################################### #
 
-import xobjects as xo
 import xtrack as xt
 
 from .materials import Material, CrystalMaterial
-from ...impacts import CollimatorImpacts
+from ..geometry import XcollGeometry
+from ...interaction_record import InteractionRecord
 from ...general import _pkg_root
 
 
-class EverestEngine(xo.HybridClass):
+class EverestEngine(xt.BeamElement):
     _xofields = {}
 
-    _depends_on = [Material, CrystalMaterial, CollimatorImpacts, xt.RandomUniform, xt.RandomExponential,
-                   xt.RandomNormal, xt.RandomRutherford, xt.Drift]
+    allow_track = False
+
+    _depends_on = [Material, CrystalMaterial, InteractionRecord, xt.RandomUniform, xt.RandomExponential,
+                   xt.RandomNormal, xt.RandomRutherford, xt.Drift, XcollGeometry]
 
     _extra_c_sources = [
+        _pkg_root.joinpath('scattering_routines','geometry','rotation.h'),
         _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','scatter_init.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','scatter.h'),
-        _pkg_root.joinpath('scattering_routines','everest','crystal.h'),
-        _pkg_root.joinpath('scattering_routines','everest','scatter_crystal.h')
+        _pkg_root.joinpath('scattering_routines','everest','channeling.h')
     ]

xcoll/scattering_routines/everest/jaw.h

@@ -1,6 +1,6 @@
 // copyright ############################### #
 // This file is part of the Xcoll Package.   #
-// Copyright (c) CERN, 2023.                 #
+// Copyright (c) CERN, 2024.                 #
 // ######################################### #
 
 #ifndef XCOLL_EVEREST_JAW_H
@@ -9,227 +9,57 @@
 #include <stdio.h>
 
 
-
 /*gpufun*/
-double* tetat(LocalParticle* part, double t, double p) {
-    double teta = sqrt(t)/p;
-    double va = 0;
-    double vb  = 0;
-    double va2 = 0;
-    double vb2 = 0;
-    double r2  = 0;
-    double* result = (double*)malloc(2 * sizeof(double));
-    
-    while (1) {
-        va  = 2*RandomUniform_generate(part) - 1;
-        vb  = RandomUniform_generate(part);
-        va2 = pow(va,2);
-        vb2 = pow(vb,2);
-        r2  = va2 + vb2;
-        if(r2 < 1) {
-            break;
-        }
+double jaw(EverestData restrict everest, LocalParticle* part, double p, double length, int edge_check) {
+    if (LocalParticle_get_state(part) < 1){
+        // Do nothing if already absorbed
+        return p;
     }
-        
-    result[0] = (teta*((2*va)*vb))/r2;
-    result[1]  = (teta*(va2 - vb2))/r2;
-    return result;
-}
-
-
-/*gpufun*/
-double* gettran(EverestData restrict everest, LocalParticle* part, double inter, double p) {
-
-    double* res = (double*)malloc(2 * sizeof(double));
-
-    // Neither if-statements below have an else, so defaulting function return to zero.
-    double result = 0;
-
-    if (inter==2) { // Nuclear Elastic
-        result = RandomExponential_generate(part)/everest->bn;
-
-    } else if (inter==3) { // pp Elastic
-        result = RandomExponential_generate(part)/everest->bpp;
-
-    } else if (inter==4) { // Single Diffractive
-        double xm2 = exp(RandomUniform_generate(part) * everest->xln15s);
-        double bsd = 0;
-        p = p * (1 - xm2/everest->ecmsq);
-    
-        if (xm2 < 2) {
-            bsd = 2 * everest->bpp;
-        } else if ((xm2 >= 2) & (xm2 <= 5)) {
-            bsd = ((106.0 - 17.0*xm2)*everest->bpp)/36.0;
-        } else {
-            bsd = (7*everest->bpp)/12.0;
-        }
-        result = RandomExponential_generate(part)/bsd;
-
-    } else if (inter==5) { // Coulomb
-        result = RandomRutherford_generate(everest->coll->rng, part);
-    }
-
-    res[0] = result;
-    res[1] = p;
-    return res;
-}
-
-
-/*gpufun*/
-int ichoix(EverestData restrict everest, LocalParticle* part) {
-
-    double aran = RandomUniform_generate(part);
-    int i;
-    for (i = 0; i < 5; ++i) {
-        if (aran < everest->cprob[i]) {
-            break;
-        }
-    }
-    return i;
-}
 
-
-/*gpufun*/
-double* jaw(EverestData restrict everest, LocalParticle* part, double p, double zlm, int edge_check) {
-
-    double* result = (double*)malloc(3 * sizeof(double));
-
-    double s;
-    double nabs = 0;
-    double rlen = zlm;
-    double m_dpodx = 0.;
-    double t;
-    double tx; 
-    double tz;
-
-    double rpp_in = LocalParticle_get_rpp(part);
-    double x  = LocalParticle_get_x(part);
-    double xp = LocalParticle_get_px(part)*rpp_in;
-    double z  = LocalParticle_get_y(part);
-    double zp = LocalParticle_get_py(part)*rpp_in;
+    double rlen = length;
+    double s0 = LocalParticle_get_s(part);
+    p /= 1e9;   // Energy (not momentum) in GeV
 
     if (everest->coll->only_mcs) {
-        double* res = mcs(everest, part, zlm, p, x, xp, z, zp, edge_check);
-        s = res[0];
-        x = res[1];
-        xp = res[2];
-        z = res[3];
-        zp = res[4];
-        free(res);
+        mcs(everest, part, rlen, p, edge_check);
 
     } else {
         // Do a step for a point-like interaction.
         // Get monte-carlo interaction length.
         while (1) {
-
             calculate_ionisation_properties(everest, p);
-            double zlm1 = everest->xintl*RandomExponential_generate(part);
+            double length_step = everest->xintl*RandomExponential_generate(part);
 
-            // If the monte-carlo interaction length is longer than the
-            // remaining collimator length, then put it to the remaining
-            // length, do multiple coulomb scattering and return.
-            // LAST STEP IN ITERATION LOOP
-            if (zlm1 > rlen) {
-                zlm1 = rlen;
-                double* res = mcs(everest, part, zlm1, p, x, xp, z, zp, edge_check);
-                s = res[0];
-                x = res[1];
-                xp = res[2];
-                z = res[3];
-                zp = res[4];
-                free(res);
-
-                s = zlm - rlen + s;
-                m_dpodx = calcionloss(everest, part, rlen);  // DM routine to include tail // TODO: should not be rlen but s after updating
-                p = p-m_dpodx*s; // This is correct: ionisation loss is only calculated and applied at end of while (break)
+            // 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);
                 break;
             }
-            // Otherwise do multi-coulomb scattering.
-            // REGULAR STEP IN ITERATION LOOP
-            double* res1 = mcs(everest, part, zlm1, p, x, xp, z, zp, edge_check);
-            s = res1[0];
-            x = res1[1];
-            xp = res1[2];
-            z = res1[3];
-            zp = res1[4];
-            free(res1);
 
-            // Check if particle is outside of collimator (X.LT.0) after
-            // MCS. If yes, calculate output longitudinal position (s),
-            // reduce momentum (output as dpop) and return.
-            // PARTICLE LEFT COLLIMATOR BEFORE ITS END.
+            // Otherwise do multi-coulomb scattering.
+            mcs(everest, part, length_step, p, edge_check);
 
-            if(x <= 0) {
-                s = zlm - rlen + s;
-                m_dpodx = calcionloss(everest, part, rlen);  // TODO: should not be rlen but s after updating
-                p = p-m_dpodx*s;  // correct
+            if(LocalParticle_get_x(part) <= 0) {
+                // PARTICLE LEFT COLLIMATOR BEFORE ITS END.
                 break;
             }
 
-            // Check whether particle is absorbed. If yes, calculate output
-            // longitudinal position (s), reduce momentum (output as dpop)
-            // and return.
-            // PARTICLE WAS ABSORBED INSIDE COLLIMATOR DURING MCS.
-
-            int inter = ichoix(everest, part);
-            nabs = inter;
-            if (inter == 1) {
-                s = zlm - rlen + zlm1;
-                m_dpodx = calcionloss(everest, part, rlen);
-                p = p-m_dpodx*s;
+            p = nuclear_interaction(everest, part, p);
+            if (LocalParticle_get_state(part) < 1){
+                // PARTICLE WAS ABSORBED INSIDE COLLIMATOR DURING MCS.
                 break;
             }
 
-
-            // Now treat the other types of interaction, as determined by ICHOIX:
-
-            // Nuclear-Elastic:          inter = 2
-            // pp Elastic:               inter = 3
-            // Single-Diffractive:       inter = 4    (changes momentum p)
-            // Coulomb:                  inter = 5
-
-            // Gettran returns some monte carlo number, that, as I believe, gives the rms transverse momentum transfer.
-
-            double* res2 = gettran(everest, part, inter, p);
-            t = res2[0];
-            p = res2[1];
-            free(res2);
-
-            // Tetat calculates from the rms transverse momentum transfer in
-            // monte-carlo fashion the angle changes for x and z planes. The
-            // angle change is proportional to SQRT(t) and 1/p, as expected.
-
-            double* res3 = tetat(part, t, p);
-            tx = res3[0];
-            tz = res3[1];
-            free(res3);
-
-            // Apply angle changes
-            xp = xp + tx;
-            zp = zp + tz;
-
-            // Treat single-diffractive scattering.    TODO: this does nothing??
-            if(inter == 4) {
-                // added update for s
-                s = zlm - rlen + zlm1;
-            }
-
             // Calculate the remaining interaction length and close the iteration loop.
-            rlen = rlen - zlm1;
+            rlen = rlen - length_step;
         }
     }
+    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)
 
-    LocalParticle_set_x(part, x);
-    LocalParticle_set_px(part, xp/rpp_in);
-    LocalParticle_set_y(part, z);
-    LocalParticle_set_py(part, zp/rpp_in);
-    LocalParticle_add_to_s(part, s);  // TODO: is this correct with tilt etc?
-
-    result[0] = p;
-    result[1] = nabs;
-    result[2] = s;
-    return result;
-}  
-  
+    return p*1e9;  // Back to eV
+}
 
 #endif /* XCOLL_EVEREST_JAW_H */

xcoll/scattering_routines/everest/materials.py

@@ -18,6 +18,8 @@ import xobjects as xo
 # as xobjects enforces a strict order: static fields first, and then dynamic fields.
 # See struct.py, in __new__ of MetaStruct
 
+# A HybridClass needs something to depend on, otherwise the class is added twice in the cdefs during compilation
+
 class GeneralMaterial(xo.HybridClass):
     _xofields = {
         'Z':                        xo.Float64,     # zatom

xcoll/scattering_routines/everest/multiple_coulomb_scattering.h

@@ -80,7 +80,7 @@ double soln3(double a, double b, double dh, double smax) {
 /*gpufun*/
 double* scamcs(LocalParticle* part, double x0, double xp0, double s) {
     double* result = (double*)malloc(2 * sizeof(double));
-    
+
     // Generate two Gaussian random numbers z1 and z2
     double r2 = 0;
     double v1 = 0;
@@ -107,7 +107,14 @@ double* scamcs(LocalParticle* part, double x0, double xp0, double s) {
 
 
 /*gpufun*/
-double* mcs(EverestData restrict everest, LocalParticle* part, double zlm1, double p, double x, double xp, double z, double zp, int edge_check) {
+void mcs(EverestData restrict everest, LocalParticle* part, double length, double p, int edge_check){
+    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 multiple coulomb scattering
+    int64_t i_slot;
+    if (sc) i_slot = InteractionRecordData_log(record, record_index, part, XC_MULTIPLE_COULOMB_SCATTERING);
 
     double const radl = everest->coll->radl;
     double s;
@@ -115,9 +122,18 @@ double* mcs(EverestData restrict everest, LocalParticle* part, double zlm1, doub
     double h   = 0.001;
     double dh  = 0.0001;
     double bn0 = 0.4330127019;
-    double rlen0 = zlm1/radl;
+    double rlen0 = length/radl;
     double rlen  = rlen0;
-    double* result = (double*)malloc(5 * sizeof(double));
+
+    double x  = LocalParticle_get_x(part);
+    double z  = LocalParticle_get_y(part);
+#ifdef XCOLL_USE_EXACT
+    double xp = LocalParticle_get_exact_xp(part);  // This is tangent
+    double zp = LocalParticle_get_exact_yp(part);  // This is tangent
+#else
+    double xp = LocalParticle_get_xp(part);
+    double zp = LocalParticle_get_yp(part);
+#endif
 
     x  = (x/theta)/radl;
     xp = xp/theta;
@@ -169,12 +185,17 @@ double* mcs(EverestData restrict everest, LocalParticle* part, double zlm1, doub
     zp = res[1];
     free(res);
 
-    result[0] = s*radl;
-    result[1] = (x*theta)*radl;
-    result[2] = xp*theta;
-    result[3] = (z*theta)*radl;
-    result[4] = zp*theta;
-    return result;
+    LocalParticle_set_x(part, x*theta*radl);
+    LocalParticle_set_y(part, z*theta*radl);
+#ifdef XCOLL_USE_EXACT
+    LocalParticle_set_exact_xp_yp(part, xp*theta, zp*theta);
+#else
+    LocalParticle_set_xp_yp(part, xp*theta, zp*theta);
+#endif
+    LocalParticle_add_to_s(part, s*radl);
+
+    // Finally log particle at end of multiple coulomb scattering
+    if (sc) InteractionRecordData_log_child(record, i_slot, part, length);
 }
 
 #endif /* XCOLL_EVEREST_MCS_H */

xcoll/scattering_routines/everest/nuclear_interaction.h

@@ -0,0 +1,86 @@
+// copyright ############################### #
+// This file is part of the Xcoll Package.   #
+// Copyright (c) CERN, 2024.                 #
+// ######################################### #
+
+#ifndef XCOLL_EVEREST_NUCL_H
+#define XCOLL_EVEREST_NUCL_H
+#include <math.h>
+#include <stdio.h>
+
+
+/*gpufun*/
+double nuclear_interaction(EverestData restrict everest, LocalParticle* part, double pc) {
+    InteractionRecordData record = everest->coll->record;
+    RecordIndex record_index     = everest->coll->record_index;
+    int8_t sc = everest->coll->record_scatterings;
+
+#ifdef XCOLL_REFINE_ENERGY
+    calculate_scattering(everest, pc);
+#endif
+
+    //Choose nuclear interaction
+    double aran = RandomUniform_generate(part);
+    int ichoix = 1;
+
+    while (aran > everest->cprob[ichoix]) {
+        ichoix += 1;
+    }
+
+    //Do the interaction
+    int64_t i_slot = -1;
+    if (ichoix==1) {
+        if (sc) i_slot = InteractionRecordData_log(record, record_index, part, XC_ABSORBED);
+        LocalParticle_set_state(part, XC_LOST_ON_EVEREST_COLL);
+
+    } else {
+        double teta;
+        if (ichoix==2) { // p-n elastic
+            if (sc) i_slot = InteractionRecordData_log(record, record_index, part, XC_PN_ELASTIC);
+            teta  = sqrt(RandomExponential_generate(part)/everest->bn)/pc;
+
+        } else if (ichoix==3) { // p-p elastic
+            if (sc) i_slot = InteractionRecordData_log(record, record_index, part, XC_PP_ELASTIC);
+            teta  = sqrt(RandomExponential_generate(part)/everest->bpp)/pc;
+
+        } else if (ichoix==4) { // Single diffractive
+            if (sc) i_slot = InteractionRecordData_log(record, record_index, part, XC_SINGLE_DIFFRACTIVE);
+            double xm2 = exp(RandomUniform_generate(part)*everest->xln15s);
+            double bsd;
+            if (xm2 < 2.) {
+                bsd = 2*everest->bpp;
+            } else if (xm2 >= 2. && xm2 <= 5.) {
+                bsd = ((106.0 - 17.0*xm2)*everest->bpp)/36.0;
+            } else {
+                bsd = (7*everest->bpp)/12.0;
+            }
+            double pc_in = pc;
+            pc = pc*(1 - xm2/everest->ecmsq);
+            // Corrected 1/p into 1/sqrt(pp')
+            teta = sqrt(RandomExponential_generate(part)/bsd)/sqrt(pc_in*pc);
+
+        } else { // Coulomb
+            if (sc) i_slot = InteractionRecordData_log(record, record_index, part, XC_COULOMB);
+            teta = sqrt(RandomRutherford_generate(everest->coll->rng, part))/pc;
+        }
+
+        // TODO: I am not convinced that we can just sample two independent random numbers
+        // I believe it should be tan(tx) = cos(phi) * tan(teta)    and    tan(ty) = sin(phi) * tan(teta)
+        // with phi uniformly sampled between 0 and 2 pi
+        double tx = teta*RandomNormal_generate(part);
+        double tz = teta*RandomNormal_generate(part);
+
+        //Change the angles
+#ifdef XCOLL_USE_EXACT
+        LocalParticle_add_to_exact_xp_yp(part, tx, tz);
+#else
+        LocalParticle_add_to_xp_yp(part, tx, tz);
+#endif
+
+        if (sc) InteractionRecordData_log_child(record, i_slot, part, 0);
+    }
+
+    return pc;
+}
+
+#endif /* XCOLL_EVEREST_NUCL_H */

xcoll/scattering_routines/geometry/__init__.py

@@ -0,0 +1,6 @@
+# copyright ############################### #
+# This file is part of the Xcoll Package.   #
+# Copyright (c) CERN, 2024.                 #
+# ######################################### #
+
+from .geometry import XcollGeometry