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

xcoll/scattering_routines/geant4/collimasim/tests/test_xtrack_tracking.py

@@ -0,0 +1,97 @@
+import numpy as np
+import xobjects as xo
+import xtrack as xt
+import xpart as xp
+
+import collimasim as cs
+
+import multiprocessing
+
+def make_particles():
+    np.random.seed(seed=1994)
+    n_part = 5000
+    particles = xp.Particles(
+        _capacity=n_part,
+		p0c = 185.e9,
+        mass0 = xp.ELECTRON_MASS_EV,
+        x=np.random.uniform(-1e-3, 1e-3, n_part),
+        px=np.random.uniform(-1e-4, 1e-4, n_part),
+        y=np.random.uniform(-1e-3, 1e-3, n_part),
+        py=np.random.uniform(-1e-4, 1e-4, n_part),
+        zeta=np.random.uniform(-0.1, 0.1, n_part),
+        delta=np.random.uniform(-0.9, 0.9, n_part),
+    )
+
+    return particles
+
+
+def run_g4_logitudinal(particles):
+    np.random.seed(seed=1994)
+
+    g4man = cs.Geant4CollimationManager(collimator_file="resources/CollDB_testing.dat",
+                                        bdsim_config_file="resources/settings_black_absorber.gmad",
+                                        tfs_file="resources/twiss_file_testing.tfs",
+                                        reference_pdg_id=-11,
+                                        reference_kinetic_energy=182.5e9,
+                                        emittance_norm=(1.e-3, 1.e-6),
+                                        relative_energy_cut=0.001,
+                                        seed=1993,
+                                        # batchMode=False
+                                        batchMode=True
+                                        )
+
+    coll1 = g4man.make_xtg4_collimator("coll_open") # Use new convenience method
+
+    # Generate a simple sequence
+    line = xt.Line(
+        elements=[coll1,
+                  ])
+
+    context = xo.ContextCpu() 
+    line.build_tracker(_context=context)
+
+    part_copy = particles.copy()
+    line.track(part_copy, num_turns=1)
+    part_copy.remove_unused_space()
+
+    return part_copy
+
+def run_drift_logitudinal(particles):
+
+    line = xt.Line(
+        elements=[xt.Drift(length=10),
+                  ])
+
+    context = xo.ContextCpu() 
+    line.config.XTRACK_USE_EXACT_DRIFTS = True
+    line.build_tracker(_context=context)
+
+    part_copy = particles.copy()
+    line.track(part_copy, num_turns=1)
+    part_copy.remove_unused_space()
+
+    return part_copy
+
+
+def test_xtrack_tracking():
+    particles = make_particles()
+    part_g4 = run_g4_logitudinal(particles)
+    part_dr = run_drift_logitudinal(particles)
+
+    # BDSIM tracks trough some geometry padding now, which is not corrected for now
+    # so use a fairly lenient tolerance of 1e-8 for all coordinates over 10 m of drift
+    all_close = True
+    for var in ['x', 'px', 'y', 'py', 'zeta', 'delta']:
+        atol = 1e-8
+        rtol = 1e-5
+        var_close = np.all(np.isclose(getattr(part_g4, var), getattr(part_dr, var), atol=atol, rtol=rtol))
+
+        all_close &= var_close
+        print("Var {}: {}".format(var, var_close))
+        
+    assert all_close
+
+
+
+if __name__ == '__main__':
+    test_xtrack_tracking()

xcoll/scattering_routines/geant4/collimasim/tests/test_xtrack_tracking_ions.py

@@ -0,0 +1,96 @@
+import numpy as np
+import xobjects as xo
+import xtrack as xt
+import xpart as xp
+
+import collimasim as cs
+
+import multiprocessing
+
+def make_particles():
+    np.random.seed(seed=1994)
+    n_part = 5000
+    particles = xp.Particles(
+        _capacity=n_part,
+		p0c = 36900e9,
+        mass0 = 193687676197.13638,
+        x=np.random.uniform(-1e-3, 1e-3, n_part),
+        px=np.random.uniform(-1e-4, 1e-4, n_part),
+        y=np.random.uniform(-1e-3, 1e-3, n_part),
+        py=np.random.uniform(-1e-4, 1e-4, n_part),
+        zeta=np.random.uniform(-0.1, 0.1, n_part),
+        delta=np.random.uniform(-0.4, 0.4, n_part),
+    )
+
+    return particles
+
+
+def run_g4_logitudinal(particles):
+    np.random.seed(seed=1994)
+
+    g4man = cs.Geant4CollimationManager(collimator_file="resources/CollDB_testing.dat",
+                                        bdsim_config_file="resources/settings_black_absorber.gmad",
+                                        tfs_file="resources/twiss_file_testing.tfs",
+                                        reference_pdg_id=1000822080,
+                                        reference_kinetic_energy=36706820652500.0,
+                                        emittance_norm=(5.e-5, 5.e-5),
+                                        relative_energy_cut=0.001,
+                                        seed=1993,
+                                        # batchMode=False
+                                        batchMode=True
+                                        )
+
+    coll1 = g4man.make_xtg4_collimator("coll_open") # Use new convenience method
+
+    # Generate a simple sequence
+    line = xt.Line(
+        elements=[coll1,
+                  ])
+
+    context = xo.ContextCpu() 
+    line.build_tracker(_context=context)
+
+    part_copy = particles.copy()
+    line.track(part_copy, num_turns=1)
+    part_copy.remove_unused_space()
+
+    return part_copy
+
+def run_drift_logitudinal(particles):
+
+    line = xt.Line(
+        elements=[xt.Drift(length=10),
+                  ])
+
+    context = xo.ContextCpu() 
+    line.config.XTRACK_USE_EXACT_DRIFTS = True
+    line.build_tracker(_context=context)
+
+    part_copy = particles.copy()
+    line.track(part_copy, num_turns=1)
+    part_copy.remove_unused_space()
+
+    return part_copy
+
+
+def test_xtrack_tracking():
+    particles = make_particles()
+    part_g4 = run_g4_logitudinal(particles)
+    part_dr = run_drift_logitudinal(particles)
+
+    # BDSIM tracks trough some geometry padding now, which is not corrected for now
+    # so use a fairly lenient tolerance of 1e-8 for all coordinates over 10 m of drift
+    all_close = True
+    for var in ['x', 'px', 'y', 'py', 'zeta', 'delta']:
+        atol = 1e-6 # For ions, the zeta variable doesn't seem to agree so well, e.g it is up to 1e-7 m off
+        rtol = 1e-5
+        var_close = np.all(np.isclose(getattr(part_g4, var), getattr(part_dr, var), atol=atol, rtol=rtol))
+
+        all_close &= var_close
+        print("Var {}: {}".format(var, var_close))
+    
+    assert all_close
+
+
+if __name__ == '__main__':
+    test_xtrack_tracking()

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

xcoll/scattering_routines/geometry/collimator_geometry.h

@@ -0,0 +1,218 @@
+// copyright ############################### #
+// This file is part of the Xcoll Package.   #
+// Copyright (c) CERN, 2024.                 #
+// ######################################### #
+
+#ifndef XCOLL_COLL_GEOM_H
+#define XCOLL_COLL_GEOM_H
+#include <math.h>
+#include <stdio.h>
+
+typedef struct CollimatorGeometry_ {
+    // Collimator jaws (with tilts)
+    double jaw_LU;
+    double jaw_RU;
+    double length;
+    int8_t side;
+    // Jaw angles
+    double sin_zL;
+    double cos_zL;
+    double sin_zR;
+    double cos_zR;
+    double sin_zDiff;
+    double cos_zDiff;
+    int8_t jaws_parallel;
+    // Tilts
+    double sin_yL;
+    double cos_yL;
+    double sin_yR;
+    double cos_yR;
+    // Segments
+    Segment* segments_L;
+    Segment* segments_R;
+    // Impact table
+    InteractionRecordData record;
+    RecordIndex record_index;
+    int8_t record_impacts;
+    int8_t record_exits;
+} CollimatorGeometry_;
+typedef CollimatorGeometry_* CollimatorGeometry;
+
+
+// This function checks if a particle hits a jaw (and which).
+// Return value: 0 (no hit), 1 (hit on left jaw), -1 (hit on right jaw).
+// Furthermore, the particle is moved to the location where it hits the jaw (drifted to the end if no hit),
+//              and transformed to the reference frame of that jaw.
+/*gpufun*/
+int8_t hit_jaws_check_and_transform(LocalParticle* part, CollimatorGeometry restrict cg){
+    double part_x, part_tan;
+    int8_t is_hit = 0;
+    double s_L = 1.e21;
+    double s_R = 1.e21;
+
+    // Find the first hit on the left jaw (if not a right-sided collimator)
+    if (cg->side != -1){
+        SRotation_single_particle(part, cg->sin_zL, cg->cos_zL);
+        part_x = LocalParticle_get_x(part);
+#ifdef XCOLL_USE_EXACT
+        part_tan = LocalParticle_get_exact_xp(part);
+#else
+        part_tan = LocalParticle_get_xp(part);
+#endif
+        s_L = get_s_of_first_crossing(part_x, part_tan, cg->segments_L, 3);
+        if (s_L < S_MAX){
+            is_hit = 1;
+        } else if (cg->side == 1){
+            // If left-sided and no hit, rotate back to lab frame
+            SRotation_single_particle(part, -cg->sin_zL, cg->cos_zL);
+        }
+    }
+
+    // if rightsided:            lab  frame
+    // if leftsided  and no hit: lab  frame
+    // if leftsided  and hit:    left frame
+    // if bothsided  and no hit: left frame
+    // if bothsided  and hit:    left frame
+
+    // Find the first hit on the right jaw (if not a left-sided collimator)
+    if (cg->side != 1){
+        if (cg->side == -1){
+            // We didn't rotate to the left frame earlier, so full rotation to the right frame now
+            SRotation_single_particle(part, cg->sin_zR, cg->cos_zR);
+        } else if (!cg->jaws_parallel){
+            // We rotated to the left frame before, so now rotate the difference
+            SRotation_single_particle(part, cg->sin_zDiff, cg->cos_zDiff);
+        }
+        part_x = LocalParticle_get_x(part);
+#ifdef XCOLL_USE_EXACT
+        part_tan = LocalParticle_get_exact_xp(part);
+#else
+        part_tan = LocalParticle_get_xp(part);
+#endif
+        s_R = get_s_of_first_crossing(part_x, part_tan, cg->segments_R, 3);
+        if (s_R < S_MAX && s_R < s_L){
+            is_hit = -1;
+        } else if (is_hit == 1){
+            if (!cg->jaws_parallel){
+                // Rotate back to left frame
+                SRotation_single_particle(part, -cg->sin_zDiff, cg->cos_zDiff);
+            }
+        } else {
+            // No hit, rotate back to lab frame
+            SRotation_single_particle(part, -cg->sin_zR, cg->cos_zR);
+        }
+    }
+
+    // if rightsided and no hit: lab   frame
+    // if rightsided and hit:    right frame
+    // if leftsided  and no hit: lab   frame
+    // if leftsided  and hit:    left  frame
+    // if bothsided  and no hit: lab  frame
+    // if bothsided  and hit:    hit   frame
+
+    // Drift to the impact position or end, and move to jaw frame if relevant
+    if (is_hit == 1){
+        // Move to the impact position
+#ifdef XCOLL_USE_EXACT
+        Drift_single_particle_exact(part, s_L);
+#else
+        Drift_single_particle_expanded(part, s_L);
+#endif
+        // Shift the reference frame to the jaw corner LU
+        XYShift_single_particle(part, cg->jaw_LU, 0);
+        LocalParticle_add_to_s(part, -cg->length/2*(1 - cg->cos_yL));
+        // Rotate the reference frame to tilt
+        double new_s = YRotation_single_particle_rotate_only(part, LocalParticle_get_s(part), asin(cg->sin_yL));
+        LocalParticle_set_s(part, new_s);
+        if (cg->record_impacts){
+            InteractionRecordData_log(cg->record, cg->record_index, part, XC_ENTER_JAW_L);
+        }
+
+    } else if (is_hit == -1){
+        // Move to the impact position
+#ifdef XCOLL_USE_EXACT
+        Drift_single_particle_exact(part, s_R);
+#else
+        Drift_single_particle_expanded(part, s_R);
+#endif
+        // Shift the reference frame to the jaw corner RU
+        XYShift_single_particle(part, cg->jaw_RU, 0);
+        LocalParticle_add_to_s(part, -cg->length/2*(1 - cg->cos_yR));
+        // Rotate the reference frame to tilt
+        double new_s = YRotation_single_particle_rotate_only(part, LocalParticle_get_s(part), asin(cg->sin_yR));
+        LocalParticle_set_s(part, new_s);
+        // Mirror x
+        LocalParticle_scale_x(part, -1);
+#ifdef XCOLL_USE_EXACT
+        LocalParticle_scale_exact_xp(part, -1);
+#else
+        LocalParticle_scale_xp(part, -1);
+#endif
+        if (cg->record_impacts){
+            InteractionRecordData_log(cg->record, cg->record_index, part, XC_ENTER_JAW_R);
+        }
+
+    } else {
+#ifdef XCOLL_USE_EXACT
+        Drift_single_particle_exact(part, cg->length);
+#else
+        Drift_single_particle_expanded(part, cg->length);
+#endif
+    }
+
+    return is_hit;
+}
+
+
+/*gpufun*/
+void hit_jaws_transform_back(int8_t is_hit, LocalParticle* part, CollimatorGeometry restrict cg){
+    if (is_hit != 0 && LocalParticle_get_state(part) > 0){
+        if (cg->record_exits){
+            InteractionRecordData_log(cg->record, cg->record_index, part, XC_EXIT_JAW);
+        }
+    }
+    if (is_hit == 1){
+        // Rotate back from tilt
+        double new_s = YRotation_single_particle_rotate_only(part, LocalParticle_get_s(part), -asin(cg->sin_yL));
+        LocalParticle_set_s(part, new_s);
+        // Shift the reference frame back from jaw corner LU
+        XYShift_single_particle(part, -cg->jaw_LU, 0);
+        LocalParticle_add_to_s(part, cg->length/2*(1 - cg->cos_yL));
+        // If particle survived, drift to end of element
+        if (LocalParticle_get_state(part) > 0){
+#ifdef XCOLL_USE_EXACT
+            Drift_single_particle_exact(part, cg->length - LocalParticle_get_s(part));
+#else
+            Drift_single_particle_expanded(part, cg->length - LocalParticle_get_s(part));
+#endif
+        }
+        SRotation_single_particle(part, -cg->sin_zL, cg->cos_zL);
+
+    } else if (is_hit == -1){
+        // Mirror back
+        LocalParticle_scale_x(part, -1);
+#ifdef XCOLL_USE_EXACT
+        LocalParticle_scale_exact_xp(part, -1);
+#else
+        LocalParticle_scale_xp(part, -1);
+#endif
+        // Rotate back from tilt
+        double new_s = YRotation_single_particle_rotate_only(part, LocalParticle_get_s(part), -asin(cg->sin_yR));
+        LocalParticle_set_s(part, new_s);
+        // Shift the reference frame back from jaw corner RU
+        XYShift_single_particle(part, -cg->jaw_RU, 0);
+        LocalParticle_add_to_s(part, cg->length/2*(1 - cg->cos_yR));
+        // If particle survived, drift to end of element
+        if (LocalParticle_get_state(part) > 0){
+#ifdef XCOLL_USE_EXACT
+            Drift_single_particle_exact(part, cg->length - LocalParticle_get_s(part));
+#else
+            Drift_single_particle_expanded(part, cg->length - LocalParticle_get_s(part));
+#endif
+        }
+        SRotation_single_particle(part, -cg->sin_zR, cg->cos_zR);
+    }
+}
+
+
+#endif /* XCOLL_COLL_GEOM_H */

xcoll/scattering_routines/geometry/crystal_geometry.h

@@ -0,0 +1,153 @@
+// copyright ############################### #
+// This file is part of the Xcoll Package.   #
+// Copyright (c) CERN, 2024.                 #
+// ######################################### #
+
+#ifndef XCOLL_CRY_GEOM_H
+#define XCOLL_CRY_GEOM_H
+#include <math.h>
+#include <stdio.h>
+
+typedef struct CrystalGeometry_ {
+    // Crystal inner upstream corner (with tilt)
+    double jaw_U;
+    double length;
+    int8_t side;
+    // Jaw angle
+    double sin_z;
+    double cos_z;
+    // Tilt
+    double sin_y;
+    double cos_y;
+    // Crystal geometry
+    double bending_radius;
+    double bending_angle;
+    double width;
+    double height;
+    double miscut_angle;
+    double s_B;    // Bend centre
+    double x_B;
+    double s_P;    // Miscut centre
+    double x_P;
+    double t_VImax;
+    // Segments
+    Segment* segments;
+    // Impact table
+    InteractionRecordData record;
+    RecordIndex record_index;
+    int8_t record_impacts;
+    int8_t record_exits;
+} CrystalGeometry_;
+typedef CrystalGeometry_* CrystalGeometry;
+
+
+// This function checks if a particle hits a jaw (and which).
+// Return value: 0 (no hit), 1 (hit on left jaw), -1 (hit on right jaw).
+// Furthermore, the particle is moved to the location where it hits the jaw (drifted to the end if no hit),
+//              and transformed to the reference frame of that jaw.
+/*gpufun*/
+int8_t hit_crystal_check_and_transform(LocalParticle* part, CrystalGeometry restrict cg){
+    double part_x, part_tan_x, part_y, part_tan_y;
+    double s = 1.e21;
+
+    // Crystal should be single-sided
+    if (cg->side == 0){
+        LocalParticle_kill_particle(part, XC_ERR_NOT_IMPLEMENTED);
+    }
+
+    SRotation_single_particle(part, cg->sin_z, cg->cos_z);
+    part_x = LocalParticle_get_x(part);
+#ifdef XCOLL_USE_EXACT
+    part_tan_x = LocalParticle_get_exact_xp(part);
+#else
+    part_tan_x = LocalParticle_get_xp(part);
+#endif
+    part_y = LocalParticle_get_y(part);
+#ifdef XCOLL_USE_EXACT
+    part_tan_y = LocalParticle_get_exact_yp(part);
+#else
+    part_tan_y = LocalParticle_get_yp(part);
+#endif
+    s = get_s_of_first_crossing_with_vlimit(part_x, part_tan_x, part_y, part_tan_y, cg->segments, 4, -cg->height/2, cg->height/2);
+
+    if (s < S_MAX){
+        // Hit: Drift to the impact position, and move to jaw frame if relevant
+#ifdef XCOLL_USE_EXACT
+        Drift_single_particle_exact(part, s);
+#else
+        Drift_single_particle_expanded(part, s);
+#endif
+        // Shift the reference frame to the upstream jaw corner (for a crystal, this is always at s=0)
+        XYShift_single_particle(part, cg->jaw_U, 0);
+        // Rotate the reference frame to tilt
+        double new_s = YRotation_single_particle_rotate_only(part, LocalParticle_get_s(part), asin(cg->sin_y));
+        LocalParticle_set_s(part, new_s);
+        if (cg->side == 1){
+            if (cg->record_impacts){
+                InteractionRecordData_log(cg->record, cg->record_index, part, XC_ENTER_JAW_L);
+            }
+
+        } else {
+            // Mirror x
+            LocalParticle_scale_x(part, -1);
+#ifdef XCOLL_USE_EXACT
+            LocalParticle_scale_exact_xp(part, -1);
+#else
+            LocalParticle_scale_xp(part, -1);
+#endif
+            if (cg->record_impacts){
+                InteractionRecordData_log(cg->record, cg->record_index, part, XC_ENTER_JAW_R);
+            }
+        }
+        return cg->side;
+
+    } else {
+        // No hit, rotate back to lab frame
+        SRotation_single_particle(part, -cg->sin_z, cg->cos_z);
+        // Drift to end
+#ifdef XCOLL_USE_EXACT
+        Drift_single_particle_exact(part, cg->length);
+#else
+        Drift_single_particle_expanded(part, cg->length);
+#endif
+        return 0;
+    }
+}
+
+
+/*gpufun*/
+void hit_crystal_transform_back(int8_t is_hit, LocalParticle* part, CrystalGeometry restrict cg){
+    if (is_hit != 0){
+        if (LocalParticle_get_state(part) > 0){
+            if (cg->record_exits){
+                InteractionRecordData_log(cg->record, cg->record_index, part, XC_EXIT_JAW);
+            }
+        }
+        if (cg->side == -1){
+            // Mirror back
+            LocalParticle_scale_x(part, -1);
+#ifdef XCOLL_USE_EXACT
+            LocalParticle_scale_exact_xp(part, -1);
+#else
+            LocalParticle_scale_xp(part, -1);
+#endif
+        }
+        // Rotate back from tilt
+        double new_s = YRotation_single_particle_rotate_only(part, LocalParticle_get_s(part), -asin(cg->sin_y));
+        LocalParticle_set_s(part, new_s);
+        // Shift the reference frame back from jaw corner U
+        XYShift_single_particle(part, -cg->jaw_U, 0);
+        // If particle survived, drift to end of element
+        if (LocalParticle_get_state(part) > 0){
+#ifdef XCOLL_USE_EXACT
+            Drift_single_particle_exact(part, cg->length - LocalParticle_get_s(part));
+#else
+            Drift_single_particle_expanded(part, cg->length - LocalParticle_get_s(part));
+#endif
+        }
+        SRotation_single_particle(part, -cg->sin_z, cg->cos_z);
+    }
+}
+
+
+#endif /* XCOLL_CRY_GEOM_H */

xcoll/scattering_routines/geometry/geometry.py

@@ -0,0 +1,26 @@
+# copyright ############################### #
+# This file is part of the Xcoll Package.   #
+# Copyright (c) CERN, 2024.                 #
+# ######################################### #
+
+import xtrack as xt
+from ...interaction_record import InteractionRecord
+from ...general import _pkg_root
+
+class XcollGeometry(xt.BeamElement):
+    _xofields = {}
+
+    allow_track = False
+
+    _depends_on = [xt.Drift, xt.XYShift, xt.SRotation, xt.YRotation, InteractionRecord]
+
+    _extra_c_sources = [
+        _pkg_root.joinpath('scattering_routines','geometry','sort.h'),
+        _pkg_root.joinpath('scattering_routines','geometry','segments.h'),
+        _pkg_root.joinpath('scattering_routines','geometry','objects.h'),
+        _pkg_root.joinpath('scattering_routines','geometry','methods.h'),
+        _pkg_root.joinpath('scattering_routines','geometry','get_s.h'),
+        _pkg_root.joinpath('scattering_routines','geometry','rotation.h'),
+        _pkg_root.joinpath('scattering_routines','geometry','collimator_geometry.h'),
+        _pkg_root.joinpath('scattering_routines','geometry','crystal_geometry.h')
+    ]

xcoll/scattering_routines/geometry/get_s.h

@@ -0,0 +1,92 @@
+// copyright ############################### #
+// This file is part of the Xcoll Package.   #
+// Copyright (c) CERN, 2024.                 #
+// ######################################### #
+
+#ifndef XCOLL_GEOM_GET_S_H
+#define XCOLL_GEOM_GET_S_H
+#include <math.h>
+#include <stdio.h>
+#include <stdint.h>
+#include <stdlib.h>
+
+
+// IMPORTANT:
+// These functions assume that the particle moves towards positive s!
+// (hence no backscattering/backtracking is allowed)
+
+
+/*gpufun*/
+double get_s_of_first_crossing(double part_x, double part_tan, Segment* segments, \
+                               int8_t n_segments){
+    int8_t n_hit = 0;
+    double* s = (double*) malloc(XC_MAX_CROSS_PER_SEGMENT*n_segments*sizeof(double));
+    find_crossing(&n_hit, s, part_x, part_tan, segments, n_segments);
+    if (n_hit==0){
+        // No crossing
+        free(s);
+        return S_MAX;
+    }
+    double result = s[0];
+    free(s);
+    return result;
+}
+
+/*gpufun*/
+double get_s_of_crossing_after_s(double part_x, double part_tan, Segment* segments, \
+                                 int8_t n_segments, double current_s){
+    int8_t n_hit = 0;
+    double* s = (double*) malloc(XC_MAX_CROSS_PER_SEGMENT*n_segments*sizeof(double));
+    find_crossing(&n_hit, s, part_x, part_tan, segments, n_segments);
+    for (int8_t i=0; i<n_hit; i++){
+        if (s[i] >= current_s){
+            double result = s[i];
+            free(s);
+            return result;
+        }
+    }
+    // No crossing
+    free(s);
+    return S_MAX;
+}
+
+/*gpufun*/
+double get_s_of_first_crossing_with_vlimit(double part_x, double part_tan_x, \
+                                double part_y, double part_tan_y, Segment* segments, \
+                                int8_t n_segments, double y_min, double y_max){
+    int8_t n_hit = 0;
+    double* s = (double*) malloc(XC_MAX_CROSS_PER_SEGMENT*n_segments*sizeof(double));
+    find_crossing_with_vlimit(&n_hit, s, part_x, part_tan_x, part_y, part_tan_y, \
+                              segments, n_segments, y_min, y_max);
+    if (n_hit==0){
+        // No crossing
+        free(s);
+        return S_MAX;
+    }
+    double result = s[0];
+    free(s);
+    return result;
+}
+
+/*gpufun*/
+double get_s_of_crossing_after_s_with_vlimit(double part_x, double part_tan_x, \
+                                double part_y, double part_tan_y, Segment* segments, \
+                                int8_t n_segments, double y_min, double y_max, double current_s){
+    int8_t n_hit = 0;
+    double* s = (double*) malloc(XC_MAX_CROSS_PER_SEGMENT*n_segments*sizeof(double));
+    find_crossing_with_vlimit(&n_hit, s, part_x, part_tan_x, part_y, part_tan_y, \
+                              segments, n_segments, y_min, y_max);
+    for (int8_t i=0; i<n_hit; i++){
+        if (s[i] >= current_s){
+            double result = s[i];
+            free(s);
+            return result;
+        }
+    }
+    // No crossing
+    free(s);
+    return S_MAX;
+}
+
+
+#endif /* XCOLL_GEOM_GET_S_H */