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

xcoll/scattering_routines/geometry/methods.h

@@ -0,0 +1,111 @@
+// copyright ############################### #
+// This file is part of the Xcoll Package.   #
+// Copyright (c) CERN, 2024.                 #
+// ######################################### #
+
+#ifndef XCOLL_GEOM_METHODS_H
+#define XCOLL_GEOM_METHODS_H
+#include <math.h>
+#include <stdio.h>
+#include <stdint.h>
+#include <stdlib.h>
+
+#define S_MAX 1.e21
+
+
+/*gpufun*/
+void find_crossing(int8_t* n_hit, double* s, double part_x, double part_tan, \
+                       Segment* segments, int8_t n_segments){
+    for (int8_t i=0; i<n_segments;i++) {
+        segments[i]->crossing(n_hit, s, part_x, part_tan, segments[i]);
+    }
+    sort_array_of_double(s, (int64_t) *n_hit);
+}
+
+
+// IMPORTANT:
+// The array and interval are assumed to be sorted!
+// Furthermore, the array should have one extra slot allocated at the end, in case it needs to be expanded..
+// This is always true for the arrays created by get_s, as we create them with 2*n_segments slots.
+/*gpufun*/
+void calculate_overlap_array_interval(double* arr, int8_t* length, double* interval){
+    if (arr[0] > interval[1]){
+        // No overlap
+        *length = 0;
+    }
+    if ((*length)%2 == 1){
+        // Special case: last interval of array is open until infinity,
+        // so we add an extra point at the end to represent infinity.
+        arr[*length] = S_MAX*0.1;
+        (*length)++;
+    } else if (arr[*length-1] < interval[0]){
+        // No overlap
+        *length = 0;
+    }
+    int8_t i_start = 0;
+    // Find the start of overlap
+    for (int8_t i=0; i<*length; i++){
+        if (arr[i] >= interval[0]){
+            if (i%2 == 0){
+                // This is the first point of overlap
+                i_start = i;
+            } else {
+                // The vertical restriction is the first point of overlap
+                i_start = i-1;
+                arr[i_start] = interval[0];
+            }
+            break;
+        }
+    }
+    // Find the end of overlap
+    int8_t i_stop = *length - 1;
+    for (int8_t i=0; i<*length; i++){
+        if (arr[i] >= interval[1]){
+            if (i%2 == 0){
+                // The previous point is the last point of overlap
+                i_stop = i-1;
+            } else {
+                // The vertical restriction is the first point of overlap
+                i_stop = i;
+                arr[i_stop] = interval[1];
+            }
+            break;
+        }
+    }
+    *length = i_stop - i_start + 1;
+    if (i_start > 0){
+        for (int8_t i=0; i<*length; i++){
+            arr[i] = arr[i+i_start];
+        }
+    }
+}
+
+
+/*gpufun*/
+void find_crossing_with_vlimit(int8_t* n_hit, double* s, 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){
+    if (fabs(part_tan_y) < 1.e-12){
+        // Trajectory parallel to s axis
+        if (part_y < y_min || part_y > y_max){
+            // No crossing
+            return;
+        } else {
+            // The particle is completely inside the vertical limits, so only check horizontal
+            find_crossing(n_hit, s, part_x, part_tan_x, segments, n_segments);
+            return;
+        }
+    } else {
+        find_crossing(n_hit, s, part_x, part_tan_x, segments, n_segments);
+        // restrict_s is the region [s0, s1] where the particle is inside the vertical limits
+        double* restrict_s = (double*) malloc(2*sizeof(double));
+        restrict_s[0] = (y_min - part_y)/part_tan_y;
+        restrict_s[1] = (y_max - part_y)/part_tan_y;
+        SWAP(restrict_s, 0, 1);   // To make sure these are sorted
+        calculate_overlap_array_interval(s, n_hit, restrict_s);
+        free(restrict_s);
+    }
+}
+
+
+#endif /* XCOLL_GEOM_METHODS_H */

xcoll/scattering_routines/geometry/objects.h

@@ -0,0 +1,154 @@
+// copyright ############################### #
+// This file is part of the Xcoll Package.   #
+// Copyright (c) CERN, 2024.                 #
+// ######################################### #
+
+#ifndef XCOLL_GEOM_OBJECTS_H
+#define XCOLL_GEOM_OBJECTS_H
+#include <math.h>
+#include <stdio.h>
+#include <stdint.h>
+#include <stdlib.h>
+
+
+// Assumption for all objects: the particle at -inf is outside the object (otherwise some comparisons might give wrong results)
+
+
+// Collimator jaw
+// --------------
+
+/*gpufun*/
+Segment* create_jaw(double s_U, double x_U, double s_D, double x_D, double tilt_tan, int8_t side){
+    Segment* segments= (Segment*) malloc(3*sizeof(Segment));
+    segments[0] = (Segment) create_halfopen_line_segment(s_U, x_U, tilt_tan, side);
+    segments[1] = (Segment) create_line_segment(s_U, x_U, s_D, x_D);
+    segments[2] = (Segment) create_halfopen_line_segment(s_D, x_D, tilt_tan, side);
+    return segments;
+}
+
+/*gpufun*/
+void destroy_jaw(Segment* segments){
+    free((HalfOpenLineSegment) segments[0]);
+    free((LineSegment)         segments[1]);
+    free((HalfOpenLineSegment) segments[2]);
+    free(segments);
+}
+
+
+// Polygon
+// -------
+
+/*gpufun*/
+Segment* create_polygon(double* s_poly, double* x_poly, int8_t num_polys){
+    Segment* segments= (Segment*) malloc((unsigned int) num_polys*sizeof(Segment));
+    for (int8_t i=0; i<num_polys-1; i++){
+        segments[i] = (Segment) create_line_segment(s_poly[i], x_poly[i], s_poly[i+1], x_poly[i+1]);
+    }
+    segments[num_polys-1] = (Segment) create_line_segment(s_poly[num_polys-1], x_poly[num_polys-1], \
+                                                          s_poly[0], x_poly[0]);
+    return segments;
+}
+
+/*gpufun*/
+void destroy_polygon(Segment* segments, int8_t num_polys){
+    for (int8_t i=0; i<num_polys; i++) {
+        free((LineSegment) segments[i]);
+    }
+    free(segments);
+}
+
+
+// Open polygon
+// ------------
+
+/*gpufun*/
+Segment* create_open_polygon(double* s_poly, double* x_poly, int8_t num_polys, double tilt_tan, int8_t side){
+    Segment* segments= (Segment*) malloc((num_polys+1)*sizeof(Segment));
+    segments[0] = (Segment) create_halfopen_line_segment(s_poly[0], x_poly[0], tilt_tan, side);
+    for (int8_t i=1; i<num_polys; i++){
+        segments[i] = (Segment) create_line_segment(s_poly[i-1], x_poly[i-1], s_poly[i], x_poly[i]);
+    }
+    segments[num_polys] = (Segment) create_halfopen_line_segment(s_poly[num_polys-1], x_poly[num_polys-1], \
+                                                                 tilt_tan, side);
+    return segments;
+}
+
+/*gpufun*/
+void destroy_open_polygon(Segment* segments, int8_t num_polys){
+    free((HalfOpenLineSegment) segments[0]);
+    for (int8_t i=1; i<num_polys; i++) {
+        free((LineSegment)     segments[i]);
+    }
+    free((HalfOpenLineSegment) segments[num_polys]);
+    free(segments);
+}
+
+
+// Crystal
+// -------
+
+// The four corners A, B, C, D are such that AB is the front face, BC the curve furthest from the beam,
+// CD the back face, and DA the curve closest to the beam.
+/*gpufun*/
+Segment* create_crystal(double R, double width, double length, double jaw_U, double tilt_sin, double tilt_cos){
+    Segment* segments= (Segment*) malloc(4*sizeof(Segment));
+
+    // First corner is what defines the crystal position
+    double A_s = 0;
+    double A_x = jaw_U;
+
+    // Manipulate R in function of sign
+    double sgnR = (R > 0) - (R < 0);
+    double R_short  = sgnR*(fabs(R) - width);
+    double sin_a = length/fabs(R);
+    double cos_a = sqrt(1 - length*length/R/R);
+    if (fabs(R) < 1.e-12){
+        // straight crystal - not yet implemented 
+        printf("Straight crystal not yet implemented!"); //only_for_context cpu_serial
+        fflush(stdout);                 //only_for_context cpu_serial
+        return NULL;
+
+    } else if (R < 0){
+        // This distinction is needed to keep the crystal at the same location when changing the bend direction
+        double R_temp = R_short;
+        R_short = R;
+        R = R_temp;
+    }
+
+    // Bending centre is defined w.r.t. A
+    double R_s = A_s - R*tilt_sin;
+    double R_x = A_x + R*tilt_cos;
+
+    // Three remaining corner points of crystal
+    double B_s = R_s + R_short*tilt_sin;
+    double C_s = R_s + fabs(R_short)*sin_a*tilt_cos + R_short*cos_a*tilt_sin;
+    double D_s = R_s + fabs(R)*sin_a*tilt_cos + R*cos_a*tilt_sin;
+    double B_x = R_x - R_short*tilt_cos;
+    double C_x = R_x - cos_a*tilt_cos*R_short + sin_a*tilt_sin*fabs(R_short);
+    double D_x = R_x - cos_a*tilt_cos*R + sin_a*tilt_sin*fabs(R);
+    double A_t = atan2(A_x - R_x, A_s - R_s);
+    double D_t = atan2(D_x - R_x, D_s - R_s);
+    double t1 = MIN(A_t, D_t);
+    double t2 = MAX(A_t, D_t);
+
+    // Fill segments
+    segments[0] = (Segment) create_line_segment(A_s, A_x, B_s, B_x);
+    segments[1] = (Segment) create_circular_segment(R, R_s, R_x, t1, t2);
+    segments[2] = (Segment) create_line_segment(C_s, C_x, D_s, D_x);
+    segments[3] = (Segment) create_circular_segment(R_short, R_s, R_x, t1, t2);
+
+    // printf("R: (%f, %f)   A: (%f, %f)   B: (%f, %f)   C: (%f, %f)   D: (%f, %f)   t1: %f   t2: %f\n", R_s,R_x,A_s,A_x,B_s,B_x,C_s,C_x,D_s,D_x,t1*180/3.141592653589793,t2*180/3.141592653589793); fflush(stdout);
+    return segments;
+}
+
+/*gpufun*/
+void destroy_crystal(Segment* segments){
+    free((LineSegment)     segments[0]);
+    free((CircularSegment) segments[1]);
+    free((LineSegment)     segments[2]);
+    free((CircularSegment) segments[3]);
+    free(segments);
+}
+
+
+#endif /* XCOLL_GEOM_OBJECTS_H */

xcoll/scattering_routines/geometry/rotation.h

@@ -0,0 +1,23 @@
+// copyright ############################### #
+// This file is part of the Xcoll Package.   #
+// Copyright (c) CERN, 2024.                 #
+// ######################################### #
+
+#ifndef XCOLL_GEOM_ROT_H
+#define XCOLL_GEOM_ROT_H
+#include <math.h>
+#include <stdio.h>
+
+
+/*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
+}
+
+#endif /* XCOLL_GEOM_ROT_H */

xcoll/scattering_routines/geometry/segments.h

@@ -0,0 +1,226 @@
+// copyright ############################### #
+// This file is part of the Xcoll Package.   #
+// Copyright (c) CERN, 2024.                 #
+// ######################################### #
+
+#ifndef XCOLL_GEOM_SEGMENTS_H
+#define XCOLL_GEOM_SEGMENTS_H
+#include <math.h>
+#include <stdio.h>
+#include <stdint.h>
+#include <stdlib.h>
+
+
+// These functions compare a particle trajectory (straight line with slope part_tan going
+// through the point [0, part_x]) with a given segment of specific type.
+// The results are always stored in an array s, and n_hit keeps track of the number of hits.
+
+
+#define XC_MAX_CROSS_PER_SEGMENT 2  // Update if new segment type allows more crossings
+
+
+// Function that calculates the crossing with a given segment
+typedef void (*CrossingFunc)(int8_t*, double*, double, double, void*);
+
+
+// Parent type for all segments
+// ----------------------------
+typedef struct Segment_{
+    CrossingFunc crossing;
+} Segment_;
+typedef Segment_* Segment;
+
+
+// Line segment
+// ------------
+
+// Line segment defined by two points (s1, x1), (s2, x2). The function will fill in the segment
+// points in the trajectory equation; if the results have opposite sign, the two points lie on
+// different sides of the trajectory and hence the segment is crossed.
+
+typedef struct LineSegment_ {
+    CrossingFunc crossing;
+    double point1_s;
+    double point1_x;
+    double point2_s;
+    double point2_x;
+} LineSegment_;
+typedef LineSegment_* LineSegment;
+
+/*gpufun*/
+void get_s_of_crossing_with_line_segment(int8_t* n_hit, double* s, double part_x, double part_tan, void* self){
+    // Get segment data
+    LineSegment seg = (LineSegment) self;
+    double s_p1 = seg->point1_s;
+    double s_p2 = seg->point2_s;
+    double x_p1 = seg->point1_x;
+    double x_p2 = seg->point2_x;
+    // Calculate crossings
+    double trajectory_p1 = x_p1 - part_x - s_p1*part_tan;
+    double trajectory_p2 = x_p2 - part_x - s_p2*part_tan;
+    if (trajectory_p1*trajectory_p2 <= 0){
+        // It's a crossing
+        if (fabs(s_p2 - s_p1) < 1.e-12){
+            s[*n_hit] = s_p1;
+            (*n_hit)++;
+        } else {
+            double poly_tan = (x_p2 - x_p1)/(s_p2 - s_p1);
+            if (fabs(poly_tan - part_tan) < 1.e-12){
+                s[*n_hit] = s_p1;
+                (*n_hit)++;
+            } else {
+                s[*n_hit] = (part_x - x_p1 + s_p1*poly_tan)/(poly_tan - part_tan);
+                (*n_hit)++;
+            }
+        }
+    }
+}
+
+/*gpufun*/
+LineSegment create_line_segment(double point1_s, double point1_x, double point2_s, double point2_x){
+    LineSegment seg = (LineSegment) malloc(sizeof(LineSegment_));
+    seg->crossing = &get_s_of_crossing_with_line_segment;
+    seg->point1_s = point1_s;
+    seg->point2_s = point2_s;
+    seg->point1_x = point1_x;
+    seg->point2_x = point2_x;
+    return seg;
+}
+
+
+// Half-open line segment
+// ----------------------
+
+// This function works as above, but considers a half-open segment. For this reason,
+// the function needs to know whether this is a positive or negative jaw (representing
+// to which infinite it points), and the overall tilt of the jaw.
+typedef struct HalfOpenLineSegment_ {
+    CrossingFunc crossing;
+    double point_s;
+    double point_x;
+    int8_t side;
+    // Important: this is the perpendicular angle (hence we will use -1/point_tan)
+    // This is done because the case "point_tan == 0" cannot take place in our setup,
+    // but "point_tan == inf" can (when the jaws have no tilt).
+    double point_tan;
+} HalfOpenLineSegment_;
+typedef HalfOpenLineSegment_* HalfOpenLineSegment;
+
+// A half-open segment implies one of its points lies at +-inf.
+// In practice we just add a polygon point at the wall overflow (at 1km for the x-coordinate).
+/*gpufun*/
+void get_s_of_crossing_with_halfopen_line_segment(int8_t* n_hit, double* s, double part_x, double part_tan, void* self){
+    // Get segment data
+    HalfOpenLineSegment seg = (HalfOpenLineSegment) self;
+    double s_p1 = seg->point_s;
+    double x_p1 = seg->point_x;
+    double x_p2 = 1.e3*seg->side;
+    double s_p2;
+    if (fabs(seg->point_tan) < 1.e-12){
+        s_p2 = s_p1;
+    } else {
+        s_p2 = -(x_p2 - x_p1 - s_p1/seg->point_tan)*seg->point_tan;
+    }
+    // Calculate crossings
+    double trajectory_p1 = x_p1 - part_x - s_p1*part_tan;
+    double trajectory_p2 = x_p2 - part_x - s_p2*part_tan;
+    if (trajectory_p1*trajectory_p2 <= 0){
+        // It's a crossing
+        if (fabs(s_p2 - s_p1) < 1.e-12){
+            s[*n_hit] = s_p1;
+            (*n_hit)++;
+        } else {
+            double poly_tan = (x_p2 - x_p1)/(s_p2 - s_p1);
+            if (fabs(poly_tan - part_tan) < 1.e-12){
+                s[*n_hit] = s_p1;
+                (*n_hit)++;
+            } else {
+                s[*n_hit] = (part_x - x_p1 + s_p1*poly_tan)/(poly_tan - part_tan);
+                (*n_hit)++;
+            }
+        }
+    }
+}
+
+/*gpufun*/
+HalfOpenLineSegment create_halfopen_line_segment(double point_s, double point_x, double point_tan, int8_t side){
+    HalfOpenLineSegment seg = (HalfOpenLineSegment) malloc(sizeof(HalfOpenLineSegment_));
+    seg->crossing = &get_s_of_crossing_with_halfopen_line_segment;
+    seg->point_s = point_s;
+    seg->point_x = point_x;
+    seg->side = side;
+    seg->point_tan = point_tan;
+    return seg;
+}
+
+
+// Circular arc segment
+// --------------------
+
+// This function finds the crossing points between a line defined by a point (s=0, x) and a tangent,
+// and a circular arc segment defined by a radius R, a centre (Rs, Rx), and angles t1 and t2.
+// The results are stored in an array s, and n_hit keeps track of the number of hits.
+typedef struct CircularSegment_ {
+    CrossingFunc crossing;
+    double R;
+    double centre_s;
+    double centre_x;
+    double point1_angle;
+    double point2_angle;
+} CircularSegment_;
+typedef CircularSegment_* CircularSegment;
+
+/*gpufun*/
+void get_s_of_crossing_with_circular_segment(int8_t* n_hit, double* s, double part_x, double part_tan, void* self){
+    // Get segment data
+    CircularSegment seg = (CircularSegment) self;
+    double R   = seg->R;
+    double R_s = seg->centre_s;
+    double R_x = seg->centre_x;
+    double t1  = seg->point1_angle;
+    double t2  = seg->point2_angle;
+    // Calculate crossings
+    int8_t reversed = 0;
+    if (t2 < t1){
+        reversed = 1;
+    }
+    double a = 1 + part_tan*part_tan;
+    double bb = R_s - part_tan*(part_x - R_x);
+    double c = R_s*R_s + (part_x - R_x)*(part_x - R_x) - R*R;
+    double disc = bb*bb - a*c;
+    if (disc >= 0){
+        for (int8_t i = 0; i < 2; i++) {
+            double sgnD = i*2-1; // negative and positive solutions
+            double new_s = 1/a*(bb + sgnD*sqrt(bb*bb - a*c));
+            double x = part_x + new_s*part_tan;
+            double t = atan2(x - R_x, new_s - R_s);
+            if (reversed){
+                // t2 < t1, so we are looking at the inverted region of angles
+                if (t1 >= t || t >= t2){
+                    s[*n_hit] = new_s;
+                    (*n_hit)++;
+                }
+            } else {
+                if (t1 <= t && t <= t2){
+                    s[*n_hit] = new_s;
+                    (*n_hit)++;
+                }
+            }
+        }
+    }
+}
+
+/*gpufun*/
+CircularSegment create_circular_segment(double R, double centre_s, double centre_x, double point1_angle, double point2_angle){
+    CircularSegment seg = (CircularSegment) malloc(sizeof(CircularSegment_));
+    seg->crossing = &get_s_of_crossing_with_circular_segment;
+    seg->R = R;
+    seg->centre_s = centre_s;
+    seg->centre_x = centre_x;
+    seg->point1_angle = point1_angle;
+    seg->point2_angle = point2_angle;
+    return seg;
+}
+
+
+#endif /* XCOLL_GEOM_SEGMENTS_H */

xcoll/scattering_routines/geometry/sort.h

@@ -0,0 +1,184 @@
+// copyright ############################### #
+// This file is part of the Xcoll Package.   #
+// Copyright (c) CERN, 2024.                 #
+// ######################################### #
+
+#ifndef XCOLL_GEOM_SORT_H
+#define XCOLL_GEOM_SORT_H
+#include <math.h>
+#include <stdio.h>
+#include <stdint.h>
+#include <stdlib.h>
+
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Warray-bounds"
+
+#ifdef MAX
+#undef MAX
+#pragma message ("Xcoll geometry: Compiler macro MAX redefined")
+#endif
+#define MAX(x, y) ({const __typeof__ (x) _x = (x); \
+                    const __typeof__ (y) _y = (y); \
+                    _x > _y ? _x : _y; })
+#ifdef MIN
+#undef MIN
+#pragma message ("Xcoll geometry: Compiler macro MIN redefined")
+#endif
+#define MIN(x, y) ({const __typeof__ (x) _x = (x); \
+                    const __typeof__ (y) _y = (y); \
+                    _x < _y ? _x : _y; })
+#ifdef SWAP
+#error "Xcoll geometry: Compiler macro SWAP already defined!"
+#endif
+#define SWAP(d,x,y) ({const __typeof__(*d) _x = MIN(d[x], d[y]); \
+                      const __typeof__(*d) _y = MAX(d[x], d[y]); \
+                      d[x] = _x; d[y] = _y; })
+
+
+// Fast methods
+// ------------
+
+static inline void sort_array_of_2_double(double* d){
+    SWAP(d, 0, 1);
+}
+
+static inline void sort_array_of_3_double(double* d){
+    SWAP(d, 0, 1); SWAP(d, 1, 2); SWAP(d, 0, 1);
+}
+
+static inline void sort_array_of_4_double(double* d){
+    SWAP(d, 0, 1); SWAP(d, 2, 3); SWAP(d, 0, 2); SWAP(d, 1, 3); SWAP(d, 1, 2);
+}
+
+static inline void sort_array_of_5_double(double* d){
+    SWAP(d, 0, 1); SWAP(d, 3, 4); SWAP(d, 2, 4); SWAP(d, 2, 3); SWAP(d, 1, 4);
+    SWAP(d, 0, 3); SWAP(d, 0, 2); SWAP(d, 1, 3); SWAP(d, 1, 2);
+}
+
+static inline void sort_array_of_6_double(double* d){
+    SWAP(d, 1, 2); SWAP(d, 4, 5); SWAP(d, 0, 2); SWAP(d, 3, 5); SWAP(d, 0, 1);
+    SWAP(d, 3, 4); SWAP(d, 1, 4); SWAP(d, 0, 3); SWAP(d, 2, 5); SWAP(d, 1, 3);
+    SWAP(d, 2, 4); SWAP(d, 2, 3);
+}
+
+static inline void sort_array_of_7_double(double* d){
+    SWAP(d, 1, 2); SWAP(d, 3, 4); SWAP(d, 5, 6); SWAP(d, 0, 2); SWAP(d, 3, 5);
+    SWAP(d, 4, 6); SWAP(d, 0, 1); SWAP(d, 4, 5); SWAP(d, 2, 6); SWAP(d, 0, 4);
+    SWAP(d, 1, 5); SWAP(d, 0, 3); SWAP(d, 2, 5); SWAP(d, 1, 3); SWAP(d, 2, 4);
+    SWAP(d, 2, 3);
+}
+
+static inline void sort_array_of_8_double(double* d){
+    SWAP(d, 0, 1); SWAP(d, 2, 3); SWAP(d, 4, 5); SWAP(d, 6, 7); SWAP(d, 0, 2);
+    SWAP(d, 1, 3); SWAP(d, 4, 6); SWAP(d, 5, 7); SWAP(d, 1, 2); SWAP(d, 5, 6);
+    SWAP(d, 0, 4); SWAP(d, 3, 7); SWAP(d, 1, 5); SWAP(d, 2, 6); SWAP(d, 1, 4);
+    SWAP(d, 3, 6); SWAP(d, 2, 4); SWAP(d, 3, 5); SWAP(d, 3, 4);
+}
+
+static inline void sort_array_of_2_int64(int64_t* d){
+    SWAP(d, 0, 1);
+}
+
+static inline void sort_array_of_3_int64(int64_t* d){
+    SWAP(d, 0, 1); SWAP(d, 1, 2); SWAP(d, 0, 1);
+}
+
+static inline void sort_array_of_4_int64(int64_t* d){
+    SWAP(d, 0, 1); SWAP(d, 2, 3); SWAP(d, 0, 2); SWAP(d, 1, 3); SWAP(d, 1, 2);
+}
+
+static inline void sort_array_of_5_int64(int64_t* d){
+    SWAP(d, 0, 1); SWAP(d, 3, 4); SWAP(d, 2, 4); SWAP(d, 2, 3); SWAP(d, 1, 4);
+    SWAP(d, 0, 3); SWAP(d, 0, 2); SWAP(d, 1, 3); SWAP(d, 1, 2);
+}
+
+static inline void sort_array_of_6_int64(int64_t* d){
+    SWAP(d, 1, 2); SWAP(d, 4, 5); SWAP(d, 0, 2); SWAP(d, 3, 5); SWAP(d, 0, 1);
+    SWAP(d, 3, 4); SWAP(d, 1, 4); SWAP(d, 0, 3); SWAP(d, 2, 5); SWAP(d, 1, 3);
+    SWAP(d, 2, 4); SWAP(d, 2, 3);
+}
+
+static inline void sort_array_of_7_int64(int64_t* d){
+    SWAP(d, 1, 2); SWAP(d, 3, 4); SWAP(d, 5, 6); SWAP(d, 0, 2); SWAP(d, 3, 5);
+    SWAP(d, 4, 6); SWAP(d, 0, 1); SWAP(d, 4, 5); SWAP(d, 2, 6); SWAP(d, 0, 4);
+    SWAP(d, 1, 5); SWAP(d, 0, 3); SWAP(d, 2, 5); SWAP(d, 1, 3); SWAP(d, 2, 4);
+    SWAP(d, 2, 3);
+}
+
+static inline void sort_array_of_8_int64(int64_t* d){
+    SWAP(d, 0, 1); SWAP(d, 2, 3); SWAP(d, 4, 5); SWAP(d, 6, 7); SWAP(d, 0, 2);
+    SWAP(d, 1, 3); SWAP(d, 4, 6); SWAP(d, 5, 7); SWAP(d, 1, 2); SWAP(d, 5, 6);
+    SWAP(d, 0, 4); SWAP(d, 3, 7); SWAP(d, 1, 5); SWAP(d, 2, 6); SWAP(d, 1, 4);
+    SWAP(d, 3, 6); SWAP(d, 2, 4); SWAP(d, 3, 5); SWAP(d, 3, 4);
+}
+
+
+// Generic methods
+// ---------------
+
+int cmpfunc_double(const void * a, const void * b) {
+   return ( *(double*)a - *(double*)b );
+}
+
+static inline void sort_array_of_double(double* arr, int64_t length){
+    switch(length){
+        case 2:
+            sort_array_of_2_double(arr);
+            break;
+        case 3:
+            sort_array_of_3_double(arr);
+            break;
+        case 4:
+            sort_array_of_4_double(arr);
+            break;
+        case 5:
+            sort_array_of_5_double(arr);
+            break;
+        case 6:
+            sort_array_of_6_double(arr);
+            break;
+        case 7:
+            sort_array_of_7_double(arr);
+            break;
+        case 8:
+            sort_array_of_8_double(arr);
+            break;
+        default:
+            qsort(arr, length, sizeof(double), cmpfunc_double);
+    }
+}
+
+int cmpfunc_int64(const void * a, const void * b) {
+   return ( *(int64_t*)a - *(int64_t*)b );
+}
+
+static inline void sort_array_of_int64(int64_t* arr, int64_t length){
+    switch(length){
+        case 2:
+            sort_array_of_2_int64(arr);
+            break;
+        case 3:
+            sort_array_of_3_int64(arr);
+            break;
+        case 4:
+            sort_array_of_4_int64(arr);
+            break;
+        case 5:
+            sort_array_of_5_int64(arr);
+            break;
+        case 6:
+            sort_array_of_6_int64(arr);
+            break;
+        case 7:
+            sort_array_of_7_int64(arr);
+            break;
+        case 8:
+            sort_array_of_8_int64(arr);
+            break;
+        default:
+            qsort(arr, length, sizeof(int64_t), cmpfunc_int64);
+    }
+}
+
+#pragma GCC diagnostic pop
+#endif /* XCOLL_GEOM_SORT_H */