httomolibgpu 2.1__py3-none-any.whl

httomolibgpu/__init__.py

@@ -0,0 +1,14 @@
+from httomolibgpu.misc.corr import median_filter, remove_outlier
+from httomolibgpu.misc.morph import sino_360_to_180, data_resampler
+from httomolibgpu.misc.rescale import rescale_to_int
+from httomolibgpu.prep.alignment import distortion_correction_proj_discorpy
+from httomolibgpu.prep.normalize import normalize
+from httomolibgpu.prep.phase import paganin_filter_savu, paganin_filter_tomopy
+from httomolibgpu.prep.stripe import (
+    remove_stripe_based_sorting,
+    remove_stripe_ti,
+    remove_all_stripe,
+)
+
+from httomolibgpu.recon.algorithm import FBP, LPRec, SIRT, CGLS
+from httomolibgpu.recon.rotation import find_center_vo, find_center_360, find_center_pc

httomolibgpu/cuda_kernels/__init__.py

@@ -0,0 +1,29 @@
+import os
+from typing import List, Optional, Tuple
+
+from httomolibgpu import cupywrapper
+
+cp = cupywrapper.cp
+
+
+def load_cuda_module(
+    file: str,
+    name_expressions: Optional[List[str]] = None,
+    options: Tuple[str, ...] = tuple(),
+) -> cp.RawModule:
+    """Load a CUDA module file, i.e. a .cu file, from the file system,
+    compile it, and return is as a CuPy RawModule for further
+    processing.
+    """
+
+    dir = os.path.dirname(os.path.abspath(__file__))
+    file = os.path.join(dir, file + ".cu")
+    # insert a preprocessor line directive to assist compiler errors (so line numbers show correctly in output)
+    escaped = file.replace("\\", "\\\\")
+    code = '#line 1 "{}"\n'.format(escaped)
+    with open(file, "r") as f:
+        code += f.read()
+
+    return cp.RawModule(
+        options=("-std=c++11", *options), code=code, name_expressions=name_expressions
+    )

httomolibgpu/cuda_kernels/calc_metrics.cu

@@ -0,0 +1,334 @@
+/*********************************************************************
+ * Calculate correlation-based metrics for the find_center_360 method
+ *********************************************************************
+ *
+ * The core of the find_center_360 method is calculating correlation coefficients
+ * between 2 or 3 shifted matrices, over many shifting positions.
+ *
+ * This file has cuda kernels for this purpose, which provide speedups of > 300x
+ * compared to using a straight numpy to cupy port.
+ *
+ * The key is the formula to calculate the Peason correlation coefficient.
+ * This is calculated manually for every shifted matrix position in the same kernel.
+ *
+ * The correlation coefficient between two vectors (we flatten the matrices) is:
+ *
+ * m1_norm = m1 - mean(m1)
+ * m2_norm = m2 - mean(m2)
+ * m1_sqr = dot(m1_norm, m1_norm)
+ * m2_sqr = dot(m2_norm, m2_norm)
+ * m1_m2  = dot(m1_norm, m2_norm)
+ * r = m1_m2 / sqrt(m1_sqr * m2_sqr)
+ *
+ * The kernels in the following compute these directly pretty much, taking into
+ * consideration normalisation, overlaps, and position offsets. Also note that the
+ * version with overlap requries 3 correlation coefficients (between 3 matrices).
+ */
+
+
+/** Function to perform a binary sum reduction for N-dimensional array storage.
+ * Note that the shared_mem pointer must have space for N * BLOCK_DIM elements.
+*/
+template <int N, int BLOCK_DIM=128>
+__device__ inline
+void sum_reduction_n(float* shared_mem, float v[N]) {
+    int tid = threadIdx.x;
+
+    float *smem[N];
+    #pragma unroll
+    for (int i = 0; i < N; ++i) {
+        smem[i] = shared_mem + i * BLOCK_DIM;
+        smem[i][tid] = v[i];
+    }
+
+    __syncthreads();
+    int nt = BLOCK_DIM;
+    int c = nt;
+    while (c > 1)
+    {
+        int half = c / 2;
+        if (tid < half)
+        {
+            #pragma unroll
+            for (int i = 0; i < N; ++i) {
+                smem[i][tid] += smem[i][c - tid - 1];
+            }
+        }
+        __syncthreads();
+        c = c - half;
+    }
+
+    // write back
+    #pragma unroll
+    for (int i = 0; i < N; ++i) {
+        v[i] = smem[i][0];
+    }
+}
+
+inline __device__
+float clip(float x, float min, float max) {
+    x = x < -1.0f ? -1.0f : x;
+    x = x > 1.0f ? 1.0f : x;
+    return x;
+}
+
+__device__ inline
+float sum_abs_row(const float* row, int win_width)
+{
+    float sum_abs = 0.0;
+    for (int x = 0; x < win_width; ++x) {
+        sum_abs += abs(row[x]);
+    }
+    return sum_abs;
+}
+
+
+/** Compute function without overlap, where correlation metrics with 2 matrices are calculated. */
+template <bool norm>
+__device__ void _calc_metrics_no_overlap(const float *mat1, int mat1_nx,
+                                         const float *mat2, int mat2_nx,
+                                         int win_width, int rows, int side,
+                                         float *list_metric)
+{
+    // rows of the matrix
+    const int tid = threadIdx.x;
+    // position in list_pos
+    const int i = blockIdx.y;
+    const int npos = gridDim.y;
+
+    const int pos = win_width / 2 + i;
+
+    // offset matrices for position
+    const float* mat2_roi = side == 1 ? mat2 : mat2 + mat2_nx - win_width;
+    const float* mat1_roi = mat1 + (pos - win_width / 2);
+
+    extern __shared__ float smem[];
+
+    // we store our data for reductions here
+    float v[3];
+
+    ////////////////////////
+    // 1. We  need the mean of the 2 matrices (flattend)
+    v[0] = 0.0f;
+    v[1] = 0.0f;
+
+    for (int y = tid; y < rows; y += blockDim.x)
+    {
+        float norm_factor = 1.0f;
+        if (norm) {
+            norm_factor = sum_abs_row(&mat2_roi[y * mat2_nx], win_width) /
+                sum_abs_row(&mat1_roi[y * mat1_nx], win_width);
+        }
+        for (int x = 0; x < win_width; ++x)
+        {
+            v[0] += mat1_roi[y * mat1_nx + x] * norm_factor;
+            v[1] += mat2_roi[y * mat2_nx + x];
+        }
+    }
+
+    // now reduce them to calc the mean
+    sum_reduction_n<2>(smem, v);
+
+    float mean_mat1 = v[0] / rows / win_width;
+    float mean_mat2 = v[1] / rows / win_width;
+
+    ///////////////////////////////////
+    // 2. Calculate the sum of the dot and cross-products for the 3 matrices:
+    v[0] = 0.0f;    // dot(mat1, mat1)
+    v[1] = 0.0f;    // dot(mat2, mat2)
+    v[2] = 0.0f;    // dot(mat1, mat2)
+
+    for (int y = tid; y < rows; y += blockDim.x)
+    {
+        float norm_factor = 1.0f;
+        if (norm) {
+            norm_factor = sum_abs_row(&mat2_roi[y * mat2_nx], win_width) /
+                sum_abs_row(&mat1_roi[y * mat1_nx], win_width);
+        }
+        for (int x = 0; x < win_width; ++x)
+        {
+            float mat1_roi_val = mat1_roi[y * mat1_nx + x] * norm_factor;
+            float mat2_roi_val = mat2_roi[y * mat2_nx + x];
+            mat1_roi_val -= mean_mat1;
+            mat2_roi_val -= mean_mat2;
+            v[0] += mat1_roi_val * mat1_roi_val;
+            v[1] += mat2_roi_val * mat2_roi_val;
+            v[2] += mat1_roi_val * mat2_roi_val;
+        }
+    }
+
+    // now reduce them to calc the mean
+    sum_reduction_n<3>(smem, v);
+
+    ////////////////////////////////
+    // 3. Calculate the correlation coefficients from the covariance values
+    if (tid == 0)
+    {
+        // we actually need the mean of the squares
+        float mat1_mat1 = v[0] / (rows * win_width - 1);
+        float mat2_mat2 = v[1] / (rows * win_width - 1);
+        float mat1_mat2 = v[2] / (rows * win_width - 1);
+        // not calculate correlation coeffiecient
+        float r = mat1_mat2 / sqrt(mat1_mat1 * mat2_mat2);
+        r = clip(r, -1.0f, 1.0f);
+        // metric
+        float metric = abs(1.0f - r);
+        list_metric[i] = metric;
+    }
+}
+
+
+/** Compute function with overlap, where correlation metrics with 3 matrices are calculated. */
+template <bool norm>
+__device__ void _calc_metrics_overlap(const float *mat1, int mat1_nx,
+                                      const float *mat2, int mat2_nx,
+                                      int win_width, int rows, int side,
+                                      float *list_metric)
+{
+    // rows of the matrix
+    const int tid = threadIdx.x;
+    // position in list_pos
+    const int i = blockIdx.y;
+    const int npos = gridDim.y;
+
+    const int pos = win_width / 2 + i;
+
+    // offset matrices for position
+    const float* mat2_roi = side == 1 ? mat2 : mat2 + mat2_nx - win_width;
+    const float* mat1_roi = mat1 + (pos - win_width / 2);
+
+    extern __shared__ float smem[];
+
+    // we need to space for 6 sum reductions for calculating the correlation coefficient
+    float v[6];
+
+    float d_ramp = 1.0f / (win_width - 1);
+
+    ////////////////////////
+    // 1. We  need the mean of the 3 matrices (flattend)
+    v[0] = 0.0f;
+    v[1] = 0.0f;
+    v[2] = 0.0f;
+    for (int y = tid; y < rows; y += blockDim.x)
+    {
+        float norm_factor = 1.0f;
+        if (norm) {
+            norm_factor = sum_abs_row(&mat2_roi[y * mat2_nx], win_width) /
+                sum_abs_row(&mat1_roi[y * mat1_nx], win_width);
+        }
+        for (int x = 0; x < win_width; ++x)
+        {
+            float ramp_down = 1.0f - (x * d_ramp);
+            float ramp_up = 1.0f - ramp_down;
+            float mat1_roi_val = mat1_roi[y * mat1_nx + x] * norm_factor;
+            float mat2_roi_val = mat2_roi[y * mat2_nx + x];
+            float mat_comb_val = side == 1 ?
+                (mat1_roi_val * ramp_down + mat2_roi_val * ramp_up) :
+                (mat1_roi_val * ramp_up + mat2_roi_val * ramp_down);
+
+            v[0] += mat1_roi_val;
+            v[1] += mat2_roi_val;
+            v[2] += mat_comb_val;
+        }
+    }
+
+    sum_reduction_n<3>(smem, v);
+
+    float mean_mat1 = v[0] / rows / win_width;
+    float mean_mat2 = v[1] / rows / win_width;
+    float mean_mat3 = v[2] / rows / win_width;
+
+    ///////////////////////////////////
+    // 2. Calculate the sum of the dot and cross-products for the 3 matrices:
+    v[0] = 0.0f;    // dot(mat1, mat1)
+    v[1] = 0.0f;    // dot(mat2, mat2)
+    v[2] = 0.0f;    // dot(mat_comb, mat_comb)
+    v[3] = 0.0f;    // dot(mat1, mat2)
+    v[4] = 0.0f;    // dot(mat1, mat_comb)
+    v[5] = 0.0f;    // dot(mat2, mat_comb)
+
+    for (int y = tid; y < rows; y += blockDim.x)
+    {
+        float norm_factor = 1.0f;
+        if (norm) {
+            norm_factor = sum_abs_row(&mat2_roi[y * mat2_nx], win_width) /
+                sum_abs_row(&mat1_roi[y * mat1_nx], win_width);
+        }
+        for (int x = 0; x < win_width; ++x)
+        {
+            float ramp_down = 1.0f - (x * d_ramp);
+            float ramp_up = 1.0f - ramp_down;
+            float mat1_roi_val = mat1_roi[y * mat1_nx + x] * norm_factor;
+            float mat2_roi_val = mat2_roi[y * mat2_nx + x];
+            float mat_comb_val = side == 1 ?
+                (mat1_roi_val * ramp_down + mat2_roi_val * ramp_up) :
+                (mat1_roi_val * ramp_up + mat2_roi_val * ramp_down);
+
+            // for covariance matrix, we need to remove the mean first
+            mat1_roi_val -= mean_mat1;
+            mat2_roi_val -= mean_mat2;
+            mat_comb_val -= mean_mat3;
+
+            // now sum the products
+            v[0] += mat1_roi_val * mat1_roi_val;
+            v[1] += mat2_roi_val * mat2_roi_val;
+            v[2] += mat_comb_val * mat_comb_val;
+            v[3] += mat1_roi_val * mat2_roi_val;
+            v[4] += mat1_roi_val * mat_comb_val;
+            v[5] += mat2_roi_val * mat_comb_val;
+        }
+
+    }
+
+    // 6 smem reductions
+    sum_reduction_n<6>(smem, v);
+
+    ////////////////////////////////
+    // 3. Calculate the correlation coefficients from the covariance values
+    if (tid == 0)
+    {
+        // mean values
+        float mat1_mat1 = v[0] / (rows * win_width - 1);
+        float mat2_mat2 = v[1] / (rows * win_width - 1);
+        float mat3_mat3 = v[2] / (rows * win_width - 1);
+        float mat1_mat2 = v[3] / (rows * win_width - 1);
+        float mat1_mat3 = v[4] / (rows * win_width - 1);
+        float mat2_mat3 = v[5] / (rows * win_width - 1);
+        // normalise to get correlation coefficients
+        float r12 = mat1_mat2 / sqrt(mat1_mat1 * mat2_mat2);
+        float r13 = mat1_mat3 / sqrt(mat1_mat1 * mat3_mat3);
+        float r23 = mat2_mat3 / sqrt(mat2_mat2 * mat3_mat3);
+        // clip
+        r12 = clip(r12, -1.0f, 1.0f);
+        r13 = clip(r13, -1.0f, 1.0f);
+        r23 = clip(r23, -1.0f, 1.0f);
+        // metric
+        float metric_1 = abs(1.0f - r12);
+        float metric_2 = abs(1.0f - r23);
+        float metric_3 = abs(1.0f - r13);
+        // average and output
+        list_metric[i] = (metric_1 + metric_2 + metric_3) / 3.0f;
+    }
+}
+
+
+
+
+
+/** Main entry point - it calls one of the two variants above.
+ *
+ * We use a template here, so that one of the two branches gets completely eliminated by
+ * the compiler (rather than at runtime), which reduces the register count.
+ */
+template <bool norm, bool use_overlap>
+__global__ void calc_metrics_kernel(const float *mat1, int mat1_nx,
+                                    const float *mat2, int mat2_nx,
+                                    int win_width, int rows, int side,
+                                    float *list_metric)
+{
+    if (use_overlap) {
+        _calc_metrics_overlap<norm>(mat1, mat1_nx, mat2, mat2_nx, win_width, rows, side, list_metric);
+    } else {
+        _calc_metrics_no_overlap<norm>(mat1, mat1_nx, mat2, mat2_nx, win_width, rows, side, list_metric);
+    }
+}

httomolibgpu/cuda_kernels/center_360_shifts.cu

@@ -0,0 +1,49 @@
+#include <cupy/complex.cuh>
+
+extern "C" __global__ void
+shift_whole_shifts(const float *sino2, const float *sino3,
+                   const float *__restrict__ list_shift, float *mat, int nx,
+                   int nymat) {
+  int xid = threadIdx.x + blockIdx.x * blockDim.x;
+  int yid = blockIdx.y;
+  int zid = blockIdx.z;
+  int ny = gridDim.y;
+
+  if (xid >= nx)
+    return;
+
+  float shift_col = list_shift[zid];
+  float int_part = 0.0;
+  float frac_part = modf(shift_col, &int_part);
+  if (abs(frac_part) > 1e-5f) {
+    // we have a floating point shift, so we only roll in
+    // sino3, but we leave the rest for later using scipy
+    int shift_int =
+        shift_col >= 0.0 ? int(ceil(shift_col)) : int(floor(shift_col));
+    if (shift_int >= 0 && xid < shift_int) {
+      mat[zid * nymat * nx + yid * nx + xid] = sino3[yid * nx + xid];
+    }
+    if (shift_int < 0 && xid >= nx + shift_int) {
+      mat[zid * nymat * nx + yid * nx + xid] = sino3[yid * nx + xid];
+    }
+  } else {
+    // we have an integer shift, so we can roll in directly
+    // by indexing
+    int shift_int = int(shift_col);
+    if (shift_int >= 0) {
+      if (xid >= shift_int) {
+        mat[zid * nymat * nx + yid * nx + xid] =
+            sino2[yid * nx + xid - shift_int];
+      } else {
+        mat[zid * nymat * nx + yid * nx + xid] = sino3[yid * nx + xid];
+      }
+    } else {
+      if (xid < nx + shift_int) {
+        mat[zid * nymat * nx + yid * nx + xid] =
+            sino2[yid * nx + xid - shift_int];
+      } else {
+        mat[zid * nymat * nx + yid * nx + xid] = sino3[yid * nx + xid];
+      }
+    }
+  }
+}

httomolibgpu/cuda_kernels/downsample_sino.cu

@@ -0,0 +1,36 @@
+extern "C" __global__ void downsample_sino(float *sino, int dx, int dz,
+                                           int level, float *out) {
+  // use shared memory to store the values used to "merge" columns of the
+  // sinogram in the downsampling process
+  extern __shared__ float downsampled_vals[];
+  unsigned int binsize, i, j, k, orig_ind, out_ind, output_bin_no;
+  i = blockDim.x * blockIdx.x + threadIdx.x;
+  j = 0;
+  k = blockDim.y * blockIdx.y + threadIdx.y;
+  orig_ind = (k * dz) + i;
+  binsize = 1 << level;
+  unsigned int dz_downsampled =
+      __float2uint_rd(fdividef(__uint2float_rd(dz), __uint2float_rd(binsize)));
+  unsigned int i_downsampled =
+      __float2uint_rd(fdividef(__uint2float_rd(i), __uint2float_rd(binsize)));
+  if (orig_ind < dx * dz) {
+    output_bin_no =
+        __float2uint_rd(fdividef(__uint2float_rd(i), __uint2float_rd(binsize)));
+    out_ind = (k * dz_downsampled) + i_downsampled;
+    downsampled_vals[threadIdx.y * 8 + threadIdx.x] =
+        sino[orig_ind] / __uint2float_rd(binsize);
+    // synchronise threads within thread-block so that it's guaranteed
+    // that all the required values have been copied into shared memeory
+    // to then sum and save in the downsampled output
+    __syncthreads();
+    // arbitrarily use the "beginning thread" in each "lot" of pixels
+    // for downsampling to then save the desired value in the
+    // downsampled output array
+    if (i % 4 == 0) {
+      out[out_ind] = downsampled_vals[threadIdx.y * 8 + threadIdx.x] +
+                     downsampled_vals[threadIdx.y * 8 + threadIdx.x + 1] +
+                     downsampled_vals[threadIdx.y * 8 + threadIdx.x + 2] +
+                     downsampled_vals[threadIdx.y * 8 + threadIdx.x + 3];
+    }
+  }
+}

httomolibgpu/cuda_kernels/generate_mask.cu

@@ -0,0 +1,51 @@
+extern "C" __global__ void generate_mask(const int ncol, const int nrow,
+                                         const int cen_col, const int cen_row,
+                                         const float du, const float dv,
+                                         const float radius, const float drop,
+                                         unsigned short *mask) {
+  int i = blockDim.x * blockIdx.x + threadIdx.x;
+  int j = blockIdx.y;
+
+  if (i >= ncol/2+1)
+    return;
+
+  // we only need to look at the right half as we're using a real2complex FFT
+  int outi = i;
+  i += ncol/2-1;
+
+  int pos = __float2int_ru(((j - cen_row) * dv / radius) / du);
+  int pos1 = -pos + cen_col;
+  int pos2 = pos + cen_col;
+
+  if (pos1 > pos2) {
+    int temp = pos1;
+    pos1 = pos2;
+    pos2 = temp;
+    if (pos1 >= ncol) {
+      pos1 = ncol - 1;
+    }
+    if (pos2 < 0) {
+      pos2 = 0;
+    }
+  } else {
+    if (pos1 < 0) {
+      pos1 = 0;
+    }
+    if (pos2 >= ncol) {
+      pos2 = ncol - 1;
+    }
+  }
+
+  short outval = (pos1 <= i && i <= pos2) ? 1 : 0;
+
+  // mask[cen_row - drop: cen_row + drop + 1, :] = 0
+  if (j >= cen_row - drop && j <= cen_row + drop) {
+    outval = 0;
+  }
+  // mask[:, cen_col - 1: cen_col + 2] = 0
+  if (i >= cen_col - 1 && i <= cen_col + 1) {
+    outval = 0;
+  }
+
+  mask[j * (ncol/2+1) + outi] = outval;
+}

httomolibgpu/cuda_kernels/median_kernel.cu

@@ -0,0 +1,54 @@
+template <typename Type, int diameter>
+__global__ void median_general_kernel3d(const Type *in, Type *out, float dif,
+                                      int Z, int M, int N) {
+  constexpr int radius = diameter / 2;
+  constexpr int d3 = diameter * diameter * diameter;
+  constexpr int midpoint = d3 / 2;
+
+  Type ValVec[d3];
+  const long i = blockDim.x * blockIdx.x + threadIdx.x;
+  const long j = blockDim.y * blockIdx.y + threadIdx.y;
+  const long k = blockDim.z * blockIdx.z + threadIdx.z;
+
+  if (i >= N || j >= M || k >= Z)
+    return;
+
+  long long index = static_cast<long long>(i) + N * static_cast<long long>(j) + N * M * static_cast<long long>(k);
+
+  int counter = 0;
+  for (int i_m = -radius; i_m <= radius; i_m++) {
+    long long i1 = i + i_m;   // using long long to avoid integer overflows
+    if ((i1 < 0) || (i1 >= N))
+      i1 = i;
+    for (int j_m = -radius; j_m <= radius; j_m++) {
+      long long j1 = j + j_m;
+      if ((j1 < 0) || (j1 >= M))
+        j1 = j;
+      for (int k_m = -radius; k_m <= radius; k_m++) {
+        long long k1 = k + k_m;
+        if ((k1 < 0) || (k1 >= Z))
+          k1 = k;
+        ValVec[counter] = in[i1 + N * j1 + N * M * k1];
+        counter++;
+      }
+    }
+  }  
+
+  /* do bubble sort here */
+  for (int x = 0; x < d3 - 1; x++) {
+    for (int y = 0; y < d3 - x - 1; y++) {
+      if (ValVec[y] > ValVec[y + 1]) {
+        Type temp = ValVec[y];
+        ValVec[y] = ValVec[y + 1];
+        ValVec[y + 1] = temp;
+      }
+    }
+  }
+
+  if (dif > 0.0f) {
+    /* perform dezingering */
+    out[index] =
+        fabsf(in[index] - ValVec[midpoint]) >= dif ? ValVec[midpoint] : in[index];
+  }
+  else out[index] = ValVec[midpoint]; /* median filtering */
+}

httomolibgpu/cuda_kernels/paganin_filter_gen.cu

@@ -0,0 +1,37 @@
+#include <cupy/complex.cuh>
+
+#ifndef M_PI
+#define M_PI 3.1415926535897932384626433832795f
+#endif
+
+extern "C" __global__ void
+paganin_filter_gen(int width1, int height1, float resolution, float wavelength,
+                   float distance, float ratio, complex<float> *filtercomplex) {
+  int px = threadIdx.x + blockIdx.x * blockDim.x;
+  int py = threadIdx.y + blockIdx.y * blockDim.y;
+  if (px >= width1)
+    return;
+  if (py >= height1)
+    return;
+
+  float dpx = 1.0f / (width1 * resolution);
+  float dpy = 1.0f / (height1 * resolution);
+  int centerx = (width1 + 1) / 2 - 1;
+  int centery = (height1 + 1) / 2 - 1;
+
+  float pxx = (px - centerx) * dpx;
+  float pyy = (py - centery) * dpy;
+  float pd = (pxx * pxx + pyy * pyy) * wavelength * distance * M_PI;
+             ;
+  float filter1 = 1.0f + ratio * pd;
+
+  complex<float> value = 1.0f / complex<float>(filter1, filter1);
+
+  // ifftshifting positions
+  int xshift = (width1 + 1) / 2;
+  int yshift = (height1 + 1) / 2;
+  int outX = (px + xshift) % width1;
+  int outY = (py + yshift) % height1;
+
+  filtercomplex[outY * width1 + outX] = value;
+}

httomolibgpu/cupywrapper.py

@@ -0,0 +1,19 @@
+cupy_run = False
+try:
+    import cupy as cp
+    import nvtx
+
+    try:
+        cp.cuda.Device(0).compute_capability
+        cupy_run = True
+    except cp.cuda.runtime.CUDARuntimeError:
+        print("CuPy library is a major dependency for HTTomolibgpu, please install")
+        import numpy as cp
+except ImportError as e:
+    print(
+        f"Failed to import module in {__file__} with error: {e}; defaulting to CPU-only mode"
+    )
+    from unittest.mock import Mock
+    import numpy as cp
+
+    nvtx = Mock()