lisaanalysistools 1.0.4__cp312-cp312-macosx_10_9_x86_64.whl → 1.0.6__cp312-cp312-macosx_10_9_x86_64.whl

{lisaanalysistools-1.0.4.dist-info → lisaanalysistools-1.0.6.dist-info}/METADATA

@@ -1,7 +1,7 @@
 Metadata-Version: 2.1
 Name: lisaanalysistools
-Version: 1.0.4
-Home-page: https://github.com/mikekatz04/lisa-on-gpu
+Version: 1.0.6
+Home-page: https://github.com/mikekatz04/LISAanalysistools
 Author: Michael Katz
 Author-email: mikekatz04@gmail.com
 Classifier: Programming Language :: Python :: 3
@@ -36,7 +36,9 @@ pip install lisaanalysistools
 
 If you want to install all of the tools associated with LISA Analysis Tools (Fast EMRI Waveforms, BBHx, GBGPU, fastlisaresponse, eryn), see the following instructions.
 
-LISA Analysis Tools leverages conda environments to install and use necessary packages. If you do not have [Anaconda](https://www.anaconda.com/download) or [miniconda](https://docs.anaconda.com/free/miniconda/index.html) installed, you must do this first and load your `base` conda environment. 
+LISA Analysis Tools leverages conda environments to install and use necessary packages. If you do not have [Anaconda](https://www.anaconda.com/download) or [miniconda](https://docs.anaconda.com/free/miniconda/index.html) installed, you must do this first and load your `base` conda environment. Recommended components for install in your conda environment are `lapack`, `gsl`, `hdf5`, which are needed for various waveform packages. 
+
+For an easy full install, follow these instructions.
 
 First, clone the repo and `cd` to the `LATW` directory.:
 ```
@@ -50,7 +52,11 @@ bash install.sh
 ```
 Running `bash install.sh -h` will also give you some basic install options. 
 
-If you want more flexibility, you can install each package given above separately. If you do this, you will also need # TODO: add. 
+If you want more flexibility, you can install each package given above separately.
+
+To install this software for use with NVIDIA GPUs (compute capability >5.0), you need the [CUDA toolkit](https://docs.nvidia.com/cuda/cuda-installation-guide-linux/index.html) and [CuPy](https://cupy.chainer.org/). The CUDA toolkit must have cuda version >8.0. Be sure to properly install CuPy within the correct CUDA toolkit version. Make sure the nvcc binary is on `$PATH` or set it as the `CUDA_HOME` environment variable.
+
+We are currently working on building wheels and making the GPU version pip installable. For now, to work with GPUs, git clone the repository and install it from source. 
 
 ## Contributing
 
@@ -58,9 +64,9 @@ Please read [CONTRIBUTING.md](CONTRIBUTING.md) for details on our code of conduc
 
 ## Versioning
 
-We use [SemVer](http://semver.org/) for versioning. For the versions available, see the [tags on this repository](https://github.com/BlackHolePerturbationToolkit/FastEMRIWaveforms/tags).
+We use [SemVer](http://semver.org/) for versioning. For the versions available, see the [tags on this repository](https://github.com/mikekatz04/LISAanalysistools/tags).
 
-Current Version: 1.0.4
+Current Version: 1.0.6
 
 ## Authors/Developers
 

lisaanalysistools-1.0.6.dist-info/RECORD

@@ -0,0 +1,36 @@
+lisatools/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+lisatools/_version.py,sha256=14imVuUDlv1B9HhbSkkcqdP6lnMYhzyYQVjZiFvzp6k,123
+lisatools/analysiscontainer.py,sha256=ePwTBUTEBJn2TK93_afARate9SAqUKK8c8T6DcGUx1Y,15321
+lisatools/datacontainer.py,sha256=m4gp8E2qOIFq1JPEid3jA450hdNo0yWQu770AVJdrDI,9809
+lisatools/detector.py,sha256=4XYWi8bSdM_97IL1L0EKKInO1fjRM4-FuW3gE8xeEEM,15262
+lisatools/diagnostic.py,sha256=CfPpfvDys1XyZRWmmTqTSWb0SY2eH0G_8TRnt1OxBFo,34174
+lisatools/sensitivity.py,sha256=rckXeJ_5U3cRRgbYDmt0kaTyJRjkrYfgBwos12QJJfw,27297
+lisatools/stochastic.py,sha256=XL6ZbqprfcM1rsDw3PhrqdflpQiCnZ5x4y_k4QZ9YGg,9423
+lisatools/cutils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+lisatools/cutils/detector_cpu.cpython-312-darwin.so,sha256=QQFxyuqx9L7HciApuIiw2tLkh-7Qqs4PRkiOWkqcClM,126912
+lisatools/cutils/include/Detector.hpp,sha256=dzdo8QUrrcAnfrTyytlZkQrYmVk_QWXXTL68p4COpZ8,1926
+lisatools/cutils/include/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+lisatools/cutils/include/global.hpp,sha256=3VPiqglTMRrIBXlEvDUJO2-CjKy_SLUXZt-9A1fH6lQ,572
+lisatools/cutils/src/Detector.cpp,sha256=RbPYrK70m0heUZyFha-2_FJOW8Fg9vKfZQzNIXvOqUQ,5188
+lisatools/cutils/src/Detector.cu,sha256=RbPYrK70m0heUZyFha-2_FJOW8Fg9vKfZQzNIXvOqUQ,5188
+lisatools/cutils/src/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+lisatools/cutils/src/pycppdetector.pyx,sha256=N0AyF5YPPqmHaBKuj4gZVXOt67z9qKwzpB6jlh9zWRY,5581
+lisatools/sampling/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+lisatools/sampling/likelihood.py,sha256=G2kAQ43qlhAzIFWvYsrSmHXd7WKJAzcCN2o07vRE8vc,29585
+lisatools/sampling/prior.py,sha256=1K1PMStpwO9WT0qG0aotKSyoNjuehXNbzTDtlk8Q15M,21407
+lisatools/sampling/stopping.py,sha256=Q8q7nM0wnJervhRduf2tBXZZHUVza5kJiAUAMUQXP5o,9682
+lisatools/sampling/utility.py,sha256=rOGotS0Aj8-DAWqsTVy2xWNsxsoz74BVrHEnG2mOkwU,14340
+lisatools/sampling/moves/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+lisatools/sampling/moves/skymodehop.py,sha256=0nf72eFhFMGwi0dLJci6XZz-bIMGqco2B2_J72hQvf8,3348
+lisatools/sources/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+lisatools/sources/emri/__init__.py,sha256=HjsWS4mjog_gRE4N90My6ahLKQGjNwrHIeA40R7qzw0,41
+lisatools/sources/emri/tdiwaveform.py,sha256=jaKL2PO8RlJrHP45zCa4BpRniLfdnMIP1QsIB-6jVq4,2297
+lisatools/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+lisatools/utils/constants.py,sha256=r1kVwkpbZS13JTOxj2iRxT5sMgTYX30y-S0JdVmD5Oo,1354
+lisatools/utils/pointeradjust.py,sha256=2sT-7qeYWr1pd_sHk9leVHUTSJ7jJgYIRoWQOtYqguE,2995
+lisatools/utils/utility.py,sha256=3mJoJKNGrm3KuNXIa2RUKi9WKd593V4q9XjjQZCQD0M,6831
+lisaanalysistools-1.0.6.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+lisaanalysistools-1.0.6.dist-info/METADATA,sha256=1T8XjHyoWcJMiuLG2DpQXqh181FMwc_K2adouVyiuO0,4109
+lisaanalysistools-1.0.6.dist-info/WHEEL,sha256=wTFHiv6xiwExbw_CBGcw1b3hAKzFq_QaWIv4Plh5P0w,110
+lisaanalysistools-1.0.6.dist-info/top_level.txt,sha256=qXUn8Xi8yvK0vr3QH0vvT5cmoccjSj-UPeKGLAxdYGo,10
+lisaanalysistools-1.0.6.dist-info/RECORD,,

{lisaanalysistools-1.0.4.dist-info → lisaanalysistools-1.0.6.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: bdist_wheel (0.43.0)
+Generator: setuptools (72.1.0)
 Root-Is-Purelib: false
 Tag: cp312-cp312-macosx_10_9_x86_64
 

{lisaanalysistools-1.0.4.dist-info → lisaanalysistools-1.0.6.dist-info}/top_level.txt

@@ -1,2 +1 @@
 lisatools
-src

lisatools/_version.py

@@ -1,4 +1,4 @@
-__version__ = '1.0.4'
+__version__ = '1.0.6'
 __copyright__ = "Michael L. Katz 2024"
 __name__ = "lisaanalysistools"
 __author__ = "Michael L. Katz"

lisatools/cutils/include/Detector.hpp

@@ -0,0 +1,78 @@
+#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;
+    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_)
+    {
+        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_;
+
+        // std::cout << " START " << std::endl;
+        // for (int i = 0; i < nlinks; i += 1)
+        // {
+        //     sc_r[i] = sc_r_[i];
+        //     sc_e[i] = sc_e_[i];
+        //     links[i] = links_[i];
+        //     // std::cout << i << " HAHAHAH " << sc_r_[i] << " " << sc_e_[i] << std::endl;
+        // }
+    };
+
+    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 dealloc(){
+        // delete[] links;
+        // delete[] sc_r;
+        // delete[] sc_e;
+    };
+};
+
+#endif // __DETECTOR_HPP__

lisatools/cutils/include/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/src/Detector.cpp

@@ -0,0 +1,210 @@
+#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;
+        int xxxx = 1;
+        oss << "Bad sc ind. Must be 1,2,3. Input sc is " << sc << " " << xxxx;
+        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__
+}

lisatools/cutils/src/Detector.cu

@@ -0,0 +1,210 @@
+#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;
+        int xxxx = 1;
+        oss << "Bad sc ind. Must be 1,2,3. Input sc is " << sc << " " << xxxx;
+        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__
+}