lisaanalysistools 1.1.19__cp310-cp310-macosx_14_0_arm64.whl

lisatools/cutils/Detector.cu

@@ -0,0 +1,307 @@
+#include "stdio.h"
+#include "global.hpp"
+#include "Detector.hpp"
+#include <iostream>
+#include <stdexcept>
+#include <string>
+#include <sstream>
+
+CUDA_DEVICE
+int Orbits::get_window(double t)
+{
+    int out = int(t / dt);
+    if ((out < 0) || (out >= N))
+        return -1;
+    else
+        return out;
+}
+
+CUDA_DEVICE
+int Orbits::get_link_ind(int link)
+{
+    if (link == 12)
+        return 0;
+    else if (link == 23)
+        return 1;
+    else if (link == 31)
+        return 2;
+    else if (link == 13)
+        return 3;
+    else if (link == 32)
+        return 4;
+    else if (link == 21)
+        return 5;
+    else
+#ifdef __CUDACC__
+        printf("BAD link ind. Must be 12, 23, 31, 13, 32, 21.");
+#else
+        throw std::invalid_argument("Bad link ind. Must be 12, 23, 31, 13, 32, 21.");
+#endif // __CUDACC__
+    return -1;
+}
+
+CUDA_DEVICE
+int Orbits::get_sc_ind(int sc)
+{
+    if (sc == 1)
+        return 0;
+    else if (sc == 2)
+        return 1;
+    else if (sc == 3)
+        return 2;
+    else
+    {
+#ifdef __CUDACC__
+        printf("BAD sc ind. Must be 1,2,3. %d\n", sc);
+#else
+        std::ostringstream oss;
+        oss << "Bad sc ind. Must be 1,2,3. Input sc is " << sc << " " << std::endl;
+        std::string var = oss.str();
+        throw std::invalid_argument(var);
+#endif // __CUDACC__
+    }
+    return 0;
+}
+
+CUDA_DEVICE
+double Orbits::interpolate(double t, double *in_arr, int window, int major_ndim, int major_ind, int ndim, int pos)
+{
+    double up = in_arr[((window + 1) * major_ndim + major_ind) * ndim + pos]; // down_ind * ndim + pos];
+    double down = in_arr[(window * major_ndim + major_ind) * ndim + pos];
+
+    // m *(x - x0) + y0
+    double fin = ((up - down) / dt) * (t - (dt * window)) + down;
+    // if ((ndim == 1))
+    //     printf("%d %e %e %e %e \n", window, fin, down, up, (t - (dt * window)));
+
+    return fin;
+}
+
+CUDA_DEVICE
+void Orbits::get_normal_unit_vec_ptr(Vec *vec, double t, int link)
+{
+    Vec _tmp = get_normal_unit_vec(t, link);
+    vec->x = _tmp.x;
+    vec->y = _tmp.y;
+    vec->z = _tmp.z;
+}
+
+CUDA_DEVICE
+Vec Orbits::get_normal_unit_vec(double t, int link)
+{
+    int window = get_window(t);
+    if (window == -1)
+    {
+        // out of bounds
+        return Vec(0.0, 0.0, 0.0);
+    }
+
+    int link_ind = get_link_ind(link);
+
+    int up_ind = (window + 1) * nlinks + link_ind;
+    int down_ind = window * nlinks + link_ind;
+
+    // x (pos = 0) ndim = 3
+    double x_out = interpolate(t, n_arr, window, nlinks, link_ind, 3, 0);
+    // y (pos = 1)
+    double y_out = interpolate(t, n_arr, window, nlinks, link_ind, 3, 1);
+    // z (pos = 2)
+    double z_out = interpolate(t, n_arr, window, nlinks, link_ind, 3, 2);
+
+    return Vec(x_out, y_out, z_out);
+}
+
+CUDA_DEVICE
+double Orbits::get_light_travel_time(double t, int link)
+{
+    int window = get_window(t);
+    if (window == -1)
+    {
+        // out of bounds
+        return 0.0;
+    }
+
+    int link_ind = get_link_ind(link);
+    if ((link_ind < 0) || (link_ind >= 6))
+        printf("BAD %d\n", link_ind);
+    int up_ind = (window + 1) * (nlinks + link_ind);
+    int down_ind = window * (nlinks + link_ind);
+
+    // x (pos = 0), ndim = 1
+    double ltt_out = interpolate(t, ltt_arr, window, nlinks, link_ind, 1, 0);
+
+    return ltt_out;
+}
+
+CUDA_DEVICE
+Vec Orbits::get_pos(double t, int sc)
+{
+    int window = get_window(t);
+    if (window == -1)
+    {
+        // out of bounds
+        return Vec(0.0, 0.0, 0.0);
+    }
+
+    int sc_ind = get_sc_ind(sc);
+
+    // x (pos = 0), ndim = 3
+    double x_out = interpolate(t, x_arr, window, nspacecraft, sc_ind, 3, 0);
+    // y (pos = 1), ndim = 3
+    double y_out = interpolate(t, x_arr, window, nspacecraft, sc_ind, 3, 1);
+    // z (pos = 2), ndim = 3
+    double z_out = interpolate(t, x_arr, window, nspacecraft, sc_ind, 3, 2);
+    return Vec(x_out, y_out, z_out);
+}
+
+CUDA_DEVICE
+void Orbits::get_pos_ptr(Vec *vec, double t, int sc)
+{
+    Vec _tmp = get_pos(t, sc);
+    vec->x = _tmp.x;
+    vec->y = _tmp.y;
+    vec->z = _tmp.z;
+}
+
+#define NUM_THREADS 64
+
+
+CUDA_KERNEL
+void get_light_travel_time_kernel(double *ltt, double *t, int *link, int num, Orbits &orbits)
+{
+    int start, end, increment;
+#ifdef __CUDACC__
+    start = blockIdx.x * blockDim.x + threadIdx.x;
+    end = num;
+    increment = gridDim.x * blockDim.x;
+#else  // __CUDACC__
+    start = 0;
+    end = num;
+    increment = 1;
+#endif // __CUDACC__
+
+    for (int i = start; i < end; i += increment)
+    {
+        ltt[i] = orbits.get_light_travel_time(t[i], link[i]);
+    }
+}
+
+void Orbits::get_light_travel_time_arr(double *ltt, double *t, int *link, int num)
+{
+#ifdef __CUDACC__
+    int num_blocks = std::ceil((num + NUM_THREADS - 1) / NUM_THREADS);
+
+    // copy self to GPU
+    Orbits *orbits_gpu;
+    gpuErrchk(cudaMalloc(&orbits_gpu, sizeof(Orbits)));
+    gpuErrchk(cudaMemcpy(orbits_gpu, this, sizeof(Orbits), cudaMemcpyHostToDevice));
+
+    get_light_travel_time_kernel<<<num_blocks, NUM_THREADS>>>(ltt, t, link, num, *orbits_gpu);
+    cudaDeviceSynchronize();
+    gpuErrchk(cudaGetLastError());
+
+    gpuErrchk(cudaFree(orbits_gpu));
+
+#else // __CUDACC__
+
+    get_light_travel_time_kernel(ltt, t, link, num, *this);
+
+#endif // __CUDACC__
+}
+
+
+CUDA_KERNEL
+void get_pos_kernel(double *pos_x, double *pos_y, double *pos_z, double *t, int *sc, int num, Orbits &orbits)
+{
+    int start, end, increment;
+#ifdef __CUDACC__
+    start = blockIdx.x * blockDim.x + threadIdx.x;
+    end = num;
+    increment = gridDim.x * blockDim.x;
+#else  // __CUDACC__
+    start = 0;
+    end = num;
+    increment = 1;
+#endif // __CUDACC__
+    Vec _tmp(0.0, 0.0, 0.0);
+
+    for (int i = start; i < end; i += increment)
+    {
+        _tmp = orbits.get_pos(t[i], sc[i]);
+        pos_x[i] = _tmp.x;
+        pos_y[i] = _tmp.y;
+        pos_z[i] = _tmp.z;
+    }
+}
+
+void Orbits::get_pos_arr(double *pos_x, double *pos_y, double *pos_z, double *t, int *sc, int num)
+{
+#ifdef __CUDACC__
+    int num_blocks = std::ceil((num + NUM_THREADS - 1) / NUM_THREADS);
+
+    // copy self to GPU
+    Orbits *orbits_gpu;
+    gpuErrchk(cudaMalloc(&orbits_gpu, sizeof(Orbits)));
+    gpuErrchk(cudaMemcpy(orbits_gpu, this, sizeof(Orbits), cudaMemcpyHostToDevice));
+
+    get_pos_kernel<<<num_blocks, NUM_THREADS>>>(pos_x, pos_y, pos_z, t, sc, num, *orbits_gpu);
+    cudaDeviceSynchronize();
+    gpuErrchk(cudaGetLastError());
+
+    gpuErrchk(cudaFree(orbits_gpu));
+
+#else // __CUDACC__
+
+    get_pos_kernel(pos_x, pos_y, pos_z, t, sc, num, *this);
+
+#endif // __CUDACC__
+}
+
+
+CUDA_KERNEL
+void get_normal_unit_vec_kernel(double *normal_unit_vec_x, double *normal_unit_vec_y, double *normal_unit_vec_z, double *t, int *link, int num, Orbits &orbits)
+{
+    int start, end, increment;
+#ifdef __CUDACC__
+    start = blockIdx.x * blockDim.x + threadIdx.x;
+    end = num;
+    increment = gridDim.x * blockDim.x;
+#else  // __CUDACC__
+    start = 0;
+    end = num;
+    increment = 1;
+#endif // __CUDACC__
+    Vec _tmp(0.0, 0.0, 0.0);
+
+    for (int i = start; i < end; i += increment)
+    {
+        _tmp = orbits.get_normal_unit_vec(t[i], link[i]);
+        normal_unit_vec_x[i] = _tmp.x;
+        normal_unit_vec_y[i] = _tmp.y;
+        normal_unit_vec_z[i] = _tmp.z;
+    }
+}
+
+void Orbits::get_normal_unit_vec_arr(double *normal_unit_vec_x, double *normal_unit_vec_y, double *normal_unit_vec_z, double *t, int *link, int num)
+{
+#ifdef __CUDACC__
+    int num_blocks = std::ceil((num + NUM_THREADS - 1) / NUM_THREADS);
+
+    // copy self to GPU
+    Orbits *orbits_gpu;
+    gpuErrchk(cudaMalloc(&orbits_gpu, sizeof(Orbits)));
+    gpuErrchk(cudaMemcpy(orbits_gpu, this, sizeof(Orbits), cudaMemcpyHostToDevice));
+
+    get_normal_unit_vec_kernel<<<num_blocks, NUM_THREADS>>>(normal_unit_vec_x, normal_unit_vec_y, normal_unit_vec_z, t, link, num, *orbits_gpu);
+    cudaDeviceSynchronize();
+    gpuErrchk(cudaGetLastError());
+
+    gpuErrchk(cudaFree(orbits_gpu));
+
+#else // __CUDACC__
+
+    get_normal_unit_vec_kernel(normal_unit_vec_x, normal_unit_vec_y, normal_unit_vec_z, t, link, num, *this);
+
+#endif // __CUDACC__
+}
+

lisatools/cutils/Detector.hpp

@@ -0,0 +1,84 @@
+#ifndef __DETECTOR_HPP__
+#define __DETECTOR_HPP__
+
+#include "global.hpp"
+#include <iostream>
+
+class Vec
+{
+public:
+    double x;
+    double y;
+    double z;
+
+    CUDA_DEVICE
+    Vec(double x_, double y_, double z_)
+    {
+        x = x_;
+        y = y_;
+        z = z_;
+    }
+};
+
+class Orbits
+{
+public:
+    double dt;
+    int N;
+    double *n_arr;
+    double *ltt_arr;
+    double *x_arr;
+    int nlinks;
+    int nspacecraft;
+    double armlength;
+    int *links;
+    int *sc_r;
+    int *sc_e;
+
+    Orbits(double dt_, int N_, double *n_arr_, double *ltt_arr_, double *x_arr_, int *links_, int *sc_r_, int *sc_e_, double armlength_)
+    {
+        dt = dt_;
+        N = N_;
+        n_arr = n_arr_;
+        ltt_arr = ltt_arr_;
+        x_arr = x_arr_;
+        nlinks = 6;
+        nspacecraft = 3;
+
+        sc_r = sc_r_;
+        sc_e = sc_e_;
+        links = links_;
+        armlength = armlength_;
+    };
+
+    int get_sc_r_from_arr(int i)
+    {
+        return sc_r[i];
+    };
+
+    int get_sc_e_from_arr(int i)
+    {
+        return sc_e[i];
+    };
+
+    int get_link_from_arr(int i)
+    {
+        return links[i];
+    };
+
+    CUDA_DEVICE int get_window(double t);
+    CUDA_DEVICE Vec get_normal_unit_vec(double t, int link);
+    CUDA_DEVICE double interpolate(double t, double *in_arr, int window, int major_ndim, int major_ind, int ndim, int pos);
+    CUDA_DEVICE int get_link_ind(int link);
+    CUDA_DEVICE int get_sc_ind(int sc);
+    CUDA_DEVICE double get_light_travel_time(double t, int link);
+    CUDA_DEVICE Vec get_pos(double t, int sc);
+    CUDA_DEVICE void get_normal_unit_vec_ptr(Vec *vec, double t, int link);
+    CUDA_DEVICE void get_pos_ptr(Vec *vec, double t, int sc);
+    void get_light_travel_time_arr(double *ltt, double *t, int *link, int num);
+    void get_pos_arr(double *pos_x, double *pos_y, double *pos_z, double *t, int *sc, int num);
+    void get_normal_unit_vec_arr(double *normal_unit_vec_x, double *normal_unit_vec_y, double *normal_unit_vec_z, double *t, int *link, int num);
+    void dealloc() {};
+};
+
+#endif // __DETECTOR_HPP__

lisatools/cutils/__init__.py

@@ -0,0 +1,129 @@
+from __future__ import annotations
+import dataclasses
+import enum
+import types
+import typing
+import abc
+from typing import Optional, Sequence, TypeVar, Union
+from ..utils.exceptions import *
+
+from gpubackendtools.gpubackendtools import BackendMethods, CpuBackend, Cuda11xBackend, Cuda12xBackend
+from gpubackendtools.exceptions import *
+
+@dataclasses.dataclass
+class LISAToolsBackendMethods(BackendMethods):
+    pycppDetector: object
+    # psd_likelihood: typing.Callable[(...), None]
+
+class LISAToolsBackend:
+    # TODO: not ClassVar?
+    pycppDetector: object
+    # psd_likelihood: typing.Callable[(...), None]
+
+    def __init__(self, lisatools_backend_methods):
+
+        # set direct lisatools methods
+        # pass rest to general backend
+        assert isinstance(lisatools_backend_methods, LISAToolsBackendMethods)
+        self.pycppDetector = lisatools_backend_methods.pycppDetector
+        # self.psd_likelihood = lisatools_backend_methods.psd_likelihood
+    
+
+class LISAToolsCpuBackend(CpuBackend, LISAToolsBackend):
+    """Implementation of the CPU backend"""
+    
+    _backend_name = "lisatools_backend_cpu"
+    _name = "lisatools_cpu"
+    def __init__(self, *args, **kwargs):
+        CpuBackend.__init__(self, *args, **kwargs)
+        LISAToolsBackend.__init__(self, self.cpu_methods_loader())
+
+    @staticmethod
+    def cpu_methods_loader() -> LISAToolsBackendMethods:
+        try:
+            import lisatools_backend_cpu.pycppdetector
+            # import lisatools_backend_cpu.psd
+
+        except (ModuleNotFoundError, ImportError) as e:
+            raise BackendUnavailableException(
+                "'cpu' backend could not be imported."
+            ) from e
+
+        numpy = LISAToolsCpuBackend.check_numpy()
+
+        return LISAToolsBackendMethods(
+            pycppDetector=lisatools_backend_cpu.pycppdetector.pycppDetector,
+            # psd_likelihood=lisatools_backend_cpu.psd.psd_likelihood,
+            xp=numpy,
+        )
+
+
+class LISAToolsCuda11xBackend(Cuda11xBackend, LISAToolsBackend):
+
+    """Implementation of CUDA 11.x backend"""
+    _backend_name : str = "lisatools_backend_cuda11x"
+    _name = "lisatools_cuda11x"
+
+    def __init__(self, *args, **kwargs):
+        Cuda11xBackend.__init__(self, *args, **kwargs)
+        LISAToolsBackend.__init__(self, self.cuda11x_module_loader())
+        
+    @staticmethod
+    def cuda11x_module_loader():
+        try:
+            import lisatools_backend_cuda11x.pycppdetector
+            import lisatools_backend_cuda11x.psd
+
+        except (ModuleNotFoundError, ImportError) as e:
+            raise BackendUnavailableException(
+                "'cuda11x' backend could not be imported."
+            ) from e
+
+        try:
+            import cupy
+        except (ModuleNotFoundError, ImportError) as e:
+            raise MissingDependencies(
+                "'cuda11x' backend requires cupy", pip_deps=["cupy-cuda11x"]
+            ) from e
+
+        return LISAToolsBackendMethods(
+            pycppDetector=lisatools_backend_cuda11x.pycppdetector.pycppDetector,
+            # psd_likelihood=lisatools_backend_cuda11x.psd.psd_likelihood,
+            xp=cupy,
+        )
+
+class LISAToolsCuda12xBackend(Cuda12xBackend, LISAToolsBackend):
+    """Implementation of CUDA 12.x backend"""
+    _backend_name : str = "lisatools_backend_cuda12x"
+    _name = "lisatools_cuda12x"
+    
+    def __init__(self, *args, **kwargs):
+        Cuda12xBackend.__init__(self, *args, **kwargs)
+        LISAToolsBackend.__init__(self, self.cuda12x_module_loader())
+        
+    @staticmethod
+    def cuda12x_module_loader():
+        try:
+            import lisatools_backend_cuda12x.pycppdetector
+            # import lisatools_backend_cuda12x.psd
+
+        except (ModuleNotFoundError, ImportError) as e:
+            raise BackendUnavailableException(
+                "'cuda12x' backend could not be imported."
+            ) from e
+
+        try:
+            import cupy
+        except (ModuleNotFoundError, ImportError) as e:
+            raise MissingDependencies(
+                "'cuda12x' backend requires cupy", pip_deps=["cupy-cuda12x"]
+            ) from e
+
+        return LISAToolsBackendMethods(
+            pycppDetector=lisatools_backend_cuda12x.pycppdetector.pycppDetector,
+            # psd_likelihood=lisatools_backend_cuda12x.psd.psd_likelihood,
+            xp=cupy,
+        )
+
+
+"""List of existing backends, per default order of preference."""

lisatools/cutils/global.hpp

@@ -0,0 +1,28 @@
+#ifndef __GLOBAL_HPP__
+#define __GLOBAL_HPP__
+
+#ifdef __CUDACC__
+#define CUDA_KERNEL __global__
+#define CUDA_DEVICE __device__
+
+#else // __CUDACC__
+#define CUDA_KERNEL 
+#define CUDA_DEVICE  
+
+#endif // __CUDACC__
+
+#ifdef __CUDACC__
+#define gpuErrchk(ans) { gpuAssert((ans), __FILE__, __LINE__); }
+inline void gpuAssert(cudaError_t code, const char *file, int line, bool abort=true)
+{
+   if (code != cudaSuccess)
+   {
+      fprintf(stderr,"GPUassert: %s %s %d\n", cudaGetErrorString(code), file, line);
+      if (abort) exit(code);
+   }
+}
+
+#endif
+
+
+#endif // __GLOBAL_HPP__

lisatools/cutils/pycppdetector.pxd

@@ -0,0 +1,44 @@
+import cython
+import numpy as np
+cimport numpy as np
+from libcpp.string cimport string
+from libcpp cimport bool
+from libc.stdint cimport uintptr_t
+
+
+cdef extern from "Detector.hpp":
+    cdef cppclass VecWrap "Vec":
+        double x
+        double y
+        double z
+        VecWrap(double x_, double y_, double z_) except+
+
+    cdef cppclass OrbitsWrap "Orbits":
+        OrbitsWrap(double dt_, int N_, double *n_arr_, double *L_arr_, double *x_arr_, int *links_, int *sc_r_, int *sc_e_, double armlength_) except+
+        int get_window(double t) except+
+        void get_normal_unit_vec_ptr(VecWrap *vec, double t, int link)
+        int get_link_ind(int link) except+
+        int get_sc_ind(int sc) except+
+        double get_light_travel_time(double t, int link) except+
+        VecWrap get_pos_ptr(VecWrap* out, double t, int sc) except+
+        void get_light_travel_time_arr(double *ltt, double *t, int *link, int num) except+
+        void dealloc();
+        void get_pos_arr(double *pos_x, double *pos_y, double *pos_z, double *t, int *sc, int num) except+
+        void get_normal_unit_vec_arr(double *normal_unit_vec_x, double *normal_unit_vec_y, double *normal_unit_vec_z, double *t, int *link, int num) except+
+        int get_sc_r_from_arr(int i) except+
+        int get_sc_e_from_arr(int i) except+
+        int get_link_from_arr(int i) except+
+        
+
+
+cdef class pycppDetector:
+    cdef OrbitsWrap *g
+    cdef double dt
+    cdef int N
+    cdef size_t n_arr
+    cdef size_t L_arr
+    cdef size_t x_arr
+    cdef size_t links
+    cdef size_t sc_r
+    cdef size_t sc_e
+    cdef double armlength