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

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

@@ -1,7 +1,7 @@
 Metadata-Version: 2.1
 Name: lisaanalysistools
-Version: 1.0.5
-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.5
+Current Version: 1.0.6
 
 ## Authors/Developers
 

{lisaanalysistools-1.0.5.dist-info → lisaanalysistools-1.0.6.dist-info}/RECORD

@@ -1,12 +1,20 @@
 lisatools/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-lisatools/_version.py,sha256=QnhTB8xNwmBZijHj3vbB3rZZAVZJsQdBQ0N3zLG2pMY,123
+lisatools/_version.py,sha256=14imVuUDlv1B9HhbSkkcqdP6lnMYhzyYQVjZiFvzp6k,123
 lisatools/analysiscontainer.py,sha256=ePwTBUTEBJn2TK93_afARate9SAqUKK8c8T6DcGUx1Y,15321
-lisatools/datacontainer.py,sha256=W89ErPJynfeioZwYqcpehHVorhKsb8FLKrj69zIsKKU,9187
-lisatools/detector.py,sha256=_S7fmtOaFLIzTfVnVTXjD58rvl7-DVy2WR4aG1V-CsE,13851
+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=wdiToEj4nUpCDIb0j7vQ7netTPDDtPGPbUg8-RiFA9U,9421
-lisatools/cutils/detector.cpython-312-darwin.so,sha256=FguczB3QPZfL3CCSMEuIx3VP0jj240_Dh30anER84m8,121664
+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
@@ -21,8 +29,8 @@ 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.5.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-lisaanalysistools-1.0.5.dist-info/METADATA,sha256=zfuyj8R4brFWnqruMjtzkbTxmVQ5L9Lelh9zNrslfPs,3380
-lisaanalysistools-1.0.5.dist-info/WHEEL,sha256=KYtn_mzb_QwZSHwPlosUO3fDl70znfUFngLlrLVHeBY,111
-lisaanalysistools-1.0.5.dist-info/top_level.txt,sha256=oCQGY7qy66i_b9MCsK2fTRdbV1pcC9GsGgIDjN47Tyc,14
-lisaanalysistools-1.0.5.dist-info/RECORD,,
+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.5.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.5.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.5'
+__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__
+}

lisatools/cutils/src/pycppdetector.pyx

@@ -0,0 +1,199 @@
+import numpy as np
+cimport numpy as np
+from libcpp.string cimport string
+from libcpp cimport bool
+from lisatools.utils.pointeradjust import wrapper
+from libc.stdint cimport uintptr_t
+
+
+cdef extern from "../include/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_) 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();
+        
+
+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
+
+    def __cinit__(self, 
+        *args, 
+        **kwargs
+    ):
+        (
+            dt,
+            N, 
+            n_arr,
+            L_arr, 
+            x_arr,
+            links,
+            sc_r, 
+            sc_e
+        ), tkwargs = wrapper(*args, **kwargs)
+
+        self.dt = dt
+        self.N = N 
+        self.n_arr = n_arr
+        self.L_arr = L_arr 
+        self.x_arr = x_arr
+        self.links = links
+        self.sc_r = sc_r
+        self.sc_e = sc_e
+
+        cdef size_t n_arr_in = n_arr
+        cdef size_t L_arr_in = L_arr
+        cdef size_t x_arr_in = x_arr
+        cdef size_t links_in = links
+        cdef size_t sc_r_in = sc_r
+        cdef size_t sc_e_in = sc_e
+        
+        self.g = new OrbitsWrap(
+            dt,
+            N,
+            <double*> n_arr_in,
+            <double*> L_arr_in, 
+            <double*> x_arr_in, 
+            <int*> links_in, 
+            <int*> sc_r_in, 
+            <int*> sc_e_in
+        )
+
+    def __dealloc__(self):
+        self.g.dealloc()
+        if self.g:
+            del self.g
+
+    def __reduce__(self):
+        return (rebuild, (self.dt, self.N, self.n_arr, self.L_arr, self.x_arr, self.links, self.sc_r, self.sc_e,))
+
+    def get_window(self, t: float) -> int:
+        return self.g.get_window(t)
+
+    def get_normal_unit_vec_single(self, t: float, link: int) -> np.ndarray:
+        cdef VecWrap *out = new VecWrap(0.0, 0.0, 0.0)
+        self.g.get_normal_unit_vec_ptr(out, t, link)
+
+        return np.array([out.x, out.y, out.z])
+
+    def get_normal_unit_vec_arr(self, t: np.ndarray, link: int) -> np.ndarray:
+        output = np.zeros((len(t), 3), dtype=float)
+        assert t.ndim == 1
+        for i in range(len(t)):
+            output[i] = self.get_normal_unit_vec_single(t[i], link)
+
+        return output
+
+    def get_normal_unit_vec(self, t: np.ndarray | float, link: int) -> np.ndarray:
+
+        if isinstance(t, float):
+            return self.get_normal_unit_vec_single(t, link)
+        elif isinstance(t, np.ndarray):
+            return self.get_normal_unit_vec_arr(t, link)
+
+    def get_link_ind(self, link: int) -> int:
+        return self.g.get_link_ind(link)
+
+    def get_sc_ind(self, sc: int) -> int:
+        return self.g.get_sc_ind(sc)
+
+    def get_light_travel_time_single(self, t: float, link: int) -> float:
+        return self.g.get_light_travel_time(t, link)
+
+    def get_light_travel_time_arr(self, t: np.ndarray, link: int) -> np.ndarray:
+        output = np.zeros((len(t),), dtype=float)
+        assert t.ndim == 1
+        for i in range(len(t)):
+            output[i] = self.get_light_travel_time_single(t[i], link)
+
+        return output
+
+    def get_light_travel_time(self, t: np.ndarray | float, link: int) -> np.ndarray:
+
+        if isinstance(t, float):
+            print("t", t)
+            return self.get_light_travel_time_single(t, link)
+        elif isinstance(t, np.ndarray):
+            return self.get_light_travel_time_arr(t, link)
+    
+    def get_pos_single(self, t: float, sc: int) -> np.ndarray:
+  
+        cdef VecWrap *out = new VecWrap(0.0, 0.0, 0.0)
+        self.g.get_pos_ptr(out, t, sc)
+
+        return np.array([out.x, out.y, out.z])
+
+    def get_pos_arr(self, t: np.ndarray, sc: int) -> np.ndarray:
+        output = np.zeros((len(t), 3), dtype=float)
+        assert t.ndim == 1
+        for i in range(len(t)):
+            output[i] = self.get_pos_single(t[i], sc)
+
+        return output
+
+    def get_pos(self, t: np.ndarray | float, sc: int) -> np.ndarray:
+
+        if isinstance(t, float):
+            return self.get_pos_single(t, sc)
+        elif isinstance(t, np.ndarray):
+            return self.get_pos_arr(t, sc)
+
+    def get_light_travel_time_arr_wrap(self, *args, **kwargs):
+        (ltt, t, link, num), tkwargs = wrapper(*args, **kwargs)
+
+        cdef size_t ltt_in = ltt
+        cdef size_t t_in = t
+        cdef size_t link_in = link
+
+        self.g.get_light_travel_time_arr(
+            <double *>ltt_in,
+            <double *>t_in,
+            <int *>link_in,
+            num
+        )
+        
+
+    @property
+    def ptr(self) -> long:
+        return <uintptr_t>self.g
+    
+        
+def rebuild(dt,
+    N, 
+    n_arr,
+    L_arr, 
+    x_arr,
+    links,
+    sc_r, 
+    sc_e
+):
+    c = pycppDetector(
+        dt,
+        N, 
+        n_arr,
+        L_arr, 
+        x_arr,
+        links,
+        sc_r, 
+        sc_e
+    )
+    return c

lisatools/datacontainer.py

@@ -28,14 +28,19 @@ class DataResidualArray:
 
 
 class DataResidualArray:
-    """Container to hold sensitivity information.
+    """Container to hold Data, residual, or template information.
+
+    This class abstracts the connection with the sensitivity matrices to make this analysis
+    as generic as possible for the user frontend, while handling
+    special computations in the backend.
 
     Args:
-        f: Frequency array.
-        sens_mat: Input sensitivity list. The shape of the nested lists should represent the shape of the
-            desired matrix. Each entry in the list must be an array, :class:`Sensitivity`-derived object,
-            or a string corresponding to the :class:`Sensitivity` object.
-        **sens_kwargs: Keyword arguments to pass to :func:`Sensitivity.get_Sn`.
+        data_res_in: Data, residual, or template input information. Can be a list, numpy array
+            or another :class:`DataResidualArray`.
+        dt: Timestep in seconds.
+        f_arr: Frequency array.
+        df: Delta f in frequency domain.
+        **kwargs: For future compatibility.
 
     """
 
@@ -145,14 +150,17 @@ class DataResidualArray:
 
     @property
     def fmax(self):
+        """Maximum frequency."""
         return self._fmax
 
     @property
     def f_arr(self):
+        """Frequency array."""
         return self._f_arr
 
     @property
     def dt(self):
+        """Time step in seconds."""
         if self._dt is None:
             raise ValueError("dt cannot be determined from this f_arr input.")
 
@@ -160,6 +168,7 @@ class DataResidualArray:
 
     @property
     def Tobs(self):
+        """Observation time in seconds"""
         if self._Tobs is None:
             raise ValueError("Tobs cannot be determined from this f_arr input.")
 
@@ -167,6 +176,7 @@ class DataResidualArray:
 
     @property
     def df(self):
+        """Delta f in the frequency domain."""
         if self._df is None:
             raise ValueError("df cannot be determined from this f_arr input.")
 
@@ -174,14 +184,17 @@ class DataResidualArray:
 
     @property
     def frequency_arr(self) -> np.ndarray:
+        """Frequency array"""
         return self._f_arr
 
     @property
     def data_res_arr(self) -> np.ndarray:
+        """Actual data residual array"""
         return self._data_res_arr
 
     @data_res_arr.setter
     def data_res_arr(self, data_res_arr: List[np.ndarray] | np.ndarray) -> None:
+        """Set ``data_res_arr``."""
         self._data_res_arr_input = data_res_arr
 
         if (
@@ -214,17 +227,21 @@ class DataResidualArray:
         self._data_res_arr = np.asarray(list(new_out), dtype=complex)
 
     def __getitem__(self, index: tuple) -> np.ndarray:
+        """Index this class directly in ``self.data_res_arr``."""
         return self.data_res_arr[index]
 
     @property
     def ndim(self) -> int:
+        """Number of dimensions in the `data_res_arr`."""
         return self.data_res_arr.ndim
 
     def flatten(self) -> np.ndarray:
+        """Flatten the ``data_res_arr``."""
         return self.data_res_arr.flatten()
 
     @property
     def shape(self) -> tuple:
+        """Shape of ``data_res_arr``."""
         return self.data_res_arr.shape
 
     def loglog(

lisatools/detector.py

@@ -5,10 +5,20 @@ from dataclasses import dataclass
 import requests
 
 import numpy as np
+
+# import for cpu/gpu
+from lisatools.cutils.detector_cpu import pycppDetector as pycppDetector_cpu
+
+try:
+    import cupy as cp
+    from lisatools.cutils.detector_gpu import pycppDetector as pycppDetector_gpu
+
+except (ImportError, ModuleNotFoundError) as e:
+    pass
+
 import h5py
 from scipy import interpolate
 
-from lisatools.cutils.detector import pycppDetector
 
 SC = [1, 2, 3]
 LINKS = [12, 23, 31, 13, 32, 21]
@@ -21,14 +31,22 @@ class Orbits(ABC):
 
     Args:
         filename: File name. File should be in the style of LISAOrbits
+        use_gpu: If ``True``, use a gpu.
 
     """
 
-    def __init__(self, filename: str) -> None:
+    def __init__(self, filename: str, use_gpu: bool = False) -> None:
+        self.use_gpu = use_gpu
         self.filename = filename
         self._setup()
         self.configured = False
 
+    @property
+    def xp(self):
+        """numpy or cupy based on self.use_gpu"""
+        xp = np if not self.use_gpu else cp
+        return xp
+
     @property
     def LINKS(self) -> List[int]:
         """Link order."""
@@ -229,6 +247,8 @@ class Orbits(ABC):
                 t_arr = np.concatenate([t_arr, self.t_base[-1:]])
         elif t_arr is not None:
             assert np.all(t_arr >= self.t_base[0]) and np.all(t_arr <= self.t_base[-1])
+            make_cpp = True
+            dt = abs(t_arr[1] - t_arr[0])
 
         elif dt is not None:
             make_cpp = True
@@ -266,12 +286,12 @@ class Orbits(ABC):
             self.pycppdetector_args = (
                 dt,
                 len(self.t),
-                self.n.flatten().copy(),
-                self.ltt.flatten().copy(),
-                self.x.flatten().copy(),
-                ll,
-                lsr,
-                lse,
+                self.xp.asarray(self.n.flatten().copy()),
+                self.xp.asarray(self.ltt.flatten().copy()),
+                self.xp.asarray(self.x.flatten().copy()),
+                self.xp.asarray(ll),
+                self.xp.asarray(lsr),
+                self.xp.asarray(lse),
             )
             self.dt = dt
         else:
@@ -290,12 +310,13 @@ class Orbits(ABC):
         self._dt = dt
 
     @property
-    def pycppdetector(self) -> pycppDetector:
+    def pycppdetector(self) -> pycppDetector_cpu | pycppDetector_gpu:
         """C++ class"""
         if self._pycppdetector_args is None:
             raise ValueError(
                 "Asking for c++ class. Need to set linear_interp_setup = True when configuring."
             )
+        pycppDetector = pycppDetector_cpu if not self.use_gpu else pycppDetector_gpu
         self._pycppdetector = pycppDetector(*self._pycppdetector_args)
         return self._pycppdetector
 
@@ -335,7 +356,24 @@ class Orbits(ABC):
             Light travel times.
 
         """
-        return self.pycppdetector.get_light_travel_time(t, link)
+        if isinstance(t, float) and isinstance(link, int):
+            squeeze = True
+            t = self.xp.atleast_1d(t)
+            link = self.xp.atleast_1d(link).astype(np.int32)
+
+        else:
+            squeeze = False
+            t = self.xp.asarray(t)
+            link = self.xp.asarray(link).astype(np.int32)
+
+        ltt_out = self.xp.zeros_like(t)
+        self.pycppdetector.get_light_travel_time_arr_wrap(
+            ltt_out, t, link, len(ltt_out)
+        )
+
+        if squeeze:
+            return ltt_out[0]
+        return ltt_out
 
     def get_normal_unit_vec(self, t: float | np.ndarray, link: int) -> np.ndarray:
         """Compute link normal vector as a function of time.
@@ -378,10 +416,13 @@ class EqualArmlengthOrbits(Orbits):
 
     Orbit file: equalarmlength-orbits.h5
 
+    Args:
+        *args, **kwargs: for :class:`Orbits`.
+
     """
 
-    def __init__(self):
-        super().__init__("equalarmlength-orbits.h5")
+    def __init__(self, *args: Any, **kwargs: Any):
+        super().__init__("equalarmlength-orbits.h5", *args, **kwargs)
 
 
 class ESAOrbits(Orbits):
@@ -389,11 +430,14 @@ class ESAOrbits(Orbits):
 
     Orbit file: esa-trailing-orbits.h5
 
+    Args:
+        *args, **kwargs: for :class:`Orbits`.
+
     """
 
-    def __init__(self):
+    def __init__(self, *args, **kwargs):
         # TODO: fix this up
-        super().__init__("esa-trailing-orbits.h5")
+        super().__init__("esa-trailing-orbits.h5", *args, **kwargs)
 
 
 class DefaultOrbits(EqualArmlengthOrbits):

lisatools/stochastic.py

@@ -249,7 +249,7 @@ class FittedHyperbolicTangentGalacticForeground(HyperbolicTangentGalacticForegro
 
         Args:
             f: Frequency array.
-            Tobs: Observation time in years.
+            Tobs: Observation time in seconds.
 
         Returns:
             PSD of the Galaxy foreground noise