From 2a8e7f91a3589a16833dc4ad7c5e88d4f78ae2be Mon Sep 17 00:00:00 2001
From: LukasMahieu <lukas.mahieu@kuleuven.be>
Date: Fri, 15 Nov 2024 15:55:32 +0100
Subject: [PATCH 1/9] test for render_plot functionality

---
 tests/test_pl.py | 32 ++++++++++++++++++++++++++++++++
 1 file changed, 32 insertions(+)
 create mode 100644 tests/test_pl.py

diff --git a/tests/test_pl.py b/tests/test_pl.py
new file mode 100644
index 00000000..73cada20
--- /dev/null
+++ b/tests/test_pl.py
@@ -0,0 +1,32 @@
+import inspect
+
+import pytest
+
+import crested.pl
+
+
+def test_plot_functions_use_render_plot():
+    # Get all submodules in crested.pl
+    submodules = [crested.pl]
+    for _, obj in inspect.getmembers(crested.pl):
+        if inspect.ismodule(obj):
+            submodules.append(obj)
+
+    # Check each function in the submodules
+    for submodule in submodules:
+        for name, func in inspect.getmembers(submodule, inspect.isfunction):
+            # Skip private functions
+            if name.startswith("_"):
+                continue
+
+            # Get the source code of the function
+            source = inspect.getsource(func)
+
+            # Check if render_plot is used in the function
+            assert (
+                "render_plot" in source
+            ), f"Function {name} in {submodule.__name__} does not use render_plot"
+
+
+if __name__ == "__main__":
+    pytest.main()

From 618fb862c2268788a9f0bfe8cabb9f7cc8296b00 Mon Sep 17 00:00:00 2001
From: LukasMahieu <lukas.mahieu@kuleuven.be>
Date: Mon, 18 Nov 2024 18:06:13 +0100
Subject: [PATCH 2/9] locus scoring now uses render_plot + unit test

---
 src/crested/pl/hist/_locus_scoring.py | 80 ++++++++++++++++-----------
 tests/test_pl.py                      | 43 +++++++++++++-
 2 files changed, 90 insertions(+), 33 deletions(-)

diff --git a/src/crested/pl/hist/_locus_scoring.py b/src/crested/pl/hist/_locus_scoring.py
index 1bd8dd92..70c2986b 100644
--- a/src/crested/pl/hist/_locus_scoring.py
+++ b/src/crested/pl/hist/_locus_scoring.py
@@ -5,16 +5,17 @@
 import matplotlib.pyplot as plt
 import numpy as np
 
+from crested.pl._utils import render_plot
+
 
 def locus_scoring(
     scores: np.ndarray,
     range: tuple[int, int],
     gene_start: int | None = None,
     gene_end: int | None = None,
-    title: str = "Predictions across Genomic Regions",
     bigwig_values: np.ndarray | None = None,
     bigwig_midpoints: list[int] | None = None,
-    filename: str | None = None,
+    **kwargs,
 ):
     """
     Plot the predictions as a line chart over the entire genomic input and optionally indicate the gene locus.
@@ -33,14 +34,14 @@ def locus_scoring(
         The start position of the gene locus to highlight on the plot.
     gene_end
         The end position of the gene locus to highlight on the plot.
-    title
-        The title of the plot.
     bigwig_values
         A numpy array of values extracted from a bigWig file for the same coordinates.
     bigwig_midpoints
         A list of base pair positions corresponding to the bigwig_values.
-    filename
-        The filename to save the plot to.
+    kwargs
+        Additional arguments passed to :func:`~crested.pl.render_plot` to
+        control the final plot output. Please see :func:`~crested.pl.render_plot`
+        for details.
 
     See Also
     --------
@@ -61,12 +62,20 @@ def locus_scoring(
 
     .. image:: ../../../../docs/_static/img/examples/hist_locus_scoring.png
     """
-    # Plotting predictions
-    plt.figure(figsize=(30, 10))
-
     # Top plot: Model predictions
-    plt.subplot(2, 1, 1)
-    plt.plot(
+    if bigwig_midpoints is not None and bigwig_values is not None:
+        nrows = 2
+    else:
+        nrows = 1
+    fig, axes = plt.subplots(
+        nrows,
+        1,
+        sharex=True,
+    )
+    if nrows == 1:
+        axes = [axes]
+
+    axes[0].plot(
         np.arange(range[0], range[1]),
         scores,
         marker="o",
@@ -75,19 +84,21 @@ def locus_scoring(
         label="Prediction Score",
     )
     if gene_start is not None and gene_end is not None:
-        plt.axvspan(gene_start, gene_end, color="red", alpha=0.3, label="Gene Locus")
-    plt.title(title)
-    plt.xlabel("Genomic Position")
-    plt.ylabel("Prediction Score")
-    plt.ylim(bottom=0)
-    plt.xticks(rotation=90)
-    plt.grid(True)
-    plt.legend()
+        axes[0].axvspan(
+            gene_start, gene_end, color="red", alpha=0.3, label="Gene Locus"
+        )
+
+    axes[0].set_xlabel("Genomic Position")
+    for label in axes[0].get_xticklabels():
+        label.set_rotation(90)
+    axes[0].set_ylabel("Prediction Score")
+    axes[0].set_ylim(bottom=0)
+    axes[0].grid(True)
+    axes[0].legend()
 
     # Bottom plot: bigWig values
     if bigwig_values is not None and bigwig_midpoints is not None:
-        plt.subplot(2, 1, 2)
-        plt.plot(
+        axes[1].plot(
             bigwig_midpoints,
             bigwig_values,
             linestyle="-",
@@ -95,17 +106,24 @@ def locus_scoring(
             label="bigWig Values",
         )
         if gene_start is not None and gene_end is not None:
-            plt.axvspan(
+            axes[1].axvspan(
                 gene_start, gene_end, color="red", alpha=0.3, label="Gene Locus"
             )
-        plt.xlabel("Genomic Position")
-        plt.ylabel("bigWig Values")
-        plt.xticks(rotation=90)
-        plt.ylim(bottom=0)
-        plt.grid(True)
-        plt.legend()
+        axes[1].set_xlabel("Genomic Position")
+        axes[1].set_ylabel("bigWig Values")
+        axes[1].grid(True)
+        axes[1].legend()
 
     plt.tight_layout()
-    if filename:
-        plt.savefig(filename)
-    plt.show()
+
+    default_height = 5 * nrows
+    default_width = 30
+
+    if "width" not in kwargs:
+        kwargs["width"] = default_width
+    if "height" not in kwargs:
+        kwargs["height"] = default_height
+    if "title" not in kwargs:
+        kwargs["title"] = "Predictions across Genomic Regions"
+
+    return render_plot(fig, **kwargs)
diff --git a/tests/test_pl.py b/tests/test_pl.py
index 73cada20..1b73f223 100644
--- a/tests/test_pl.py
+++ b/tests/test_pl.py
@@ -1,5 +1,6 @@
 import inspect
 
+import numpy as np
 import pytest
 
 import crested.pl
@@ -15,8 +16,8 @@ def test_plot_functions_use_render_plot():
     # Check each function in the submodules
     for submodule in submodules:
         for name, func in inspect.getmembers(submodule, inspect.isfunction):
-            # Skip private functions
-            if name.startswith("_"):
+            # Skip private functions and render_plot function itself
+            if name.startswith("_") or name == "render_plot":
                 continue
 
             # Get the source code of the function
@@ -28,5 +29,43 @@ def test_plot_functions_use_render_plot():
             ), f"Function {name} in {submodule.__name__} does not use render_plot"
 
 
+def test_locus_scoring_without_bigwig():
+    scores = np.random.rand(100)
+    range_values = (0, 100)
+    gene_start = 20
+    gene_end = 40
+
+    fig = crested.pl.hist.locus_scoring(
+        scores=scores,
+        range=range_values,
+        gene_start=gene_start,
+        gene_end=gene_end,
+        bigwig_values=None,
+        bigwig_midpoints=None,
+        show=False,
+    )
+    assert fig is not None
+
+
+def test_locus_scoring_with_bigwig():
+    scores = np.random.rand(100)
+    range_values = (0, 100)
+    gene_start = 20
+    gene_end = 40
+    bigwig_values = np.random.rand(50)
+    bigwig_midpoints = np.linspace(0, 100, 50)
+
+    fig = crested.pl.hist.locus_scoring(
+        scores=scores,
+        range=range_values,
+        gene_start=gene_start,
+        gene_end=gene_end,
+        bigwig_values=bigwig_values,
+        bigwig_midpoints=bigwig_midpoints,
+        show=False,
+    )
+    assert fig is not None
+
+
 if __name__ == "__main__":
     pytest.main()

From c6fb078a1b3c43c661592ec255ea8a8cc66d0e82 Mon Sep 17 00:00:00 2001
From: LukasMahieu <lukas.mahieu@kuleuven.be>
Date: Tue, 19 Nov 2024 13:09:21 +0100
Subject: [PATCH 3/9] tmp testing notebook

---
 test_plotting.ipynb | 2292 +++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 2292 insertions(+)
 create mode 100644 test_plotting.ipynb

diff --git a/test_plotting.ipynb b/test_plotting.ipynb
new file mode 100644
index 00000000..458ed2cc
--- /dev/null
+++ b/test_plotting.ipynb
@@ -0,0 +1,2292 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import os\n",
+    "\n",
+    "os.environ[\"KERAS_BACKEND\"] = \"torch\"\n",
+    "import crested"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# bigwigs, regions = crested.get_dataset(\"mouse_cortex_bigwig\")\n",
+    "bigwigs = \"/home/luna.kuleuven.be/u0166574/.cache/crested/data/mouse_biccn/bigwigs.tar.gz.untar\"\n",
+    "regions = \"/home/luna.kuleuven.be/u0166574/.cache/crested/data/mouse_biccn/consensus_peaks_biccn.bed\""
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "/home/luna.kuleuven.be/u0166574/.cache/crested/data/mouse_biccn/bigwigs.tar.gz.untar\n",
+      "/home/luna.kuleuven.be/u0166574/.cache/crested/data/mouse_biccn/consensus_peaks_biccn.bed\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(bigwigs)\n",
+    "print(regions)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "2024-11-19T10:48:34.931403+0100 WARNING Chromsizes file not provided. Will not check if regions are within chromosomes\n",
+      "2024-11-19T10:48:35.832092+0100 INFO Extracting values from 19 bigWig files...\n"
+     ]
+    }
+   ],
+   "source": [
+    "adata = crested.import_bigwigs(bigwigs, regions)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Preprocess"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 31,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "2024-11-19T10:20:56.407967+0100 INFO After specificity filtering, kept 14337 out of 546993 regions.\n"
+     ]
+    }
+   ],
+   "source": [
+    "crested.pp.filter_regions_on_specificity(adata, gini_std_threshold=2.0)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "crested.pp.train_val_test_split(adata, strategy=\"region\", val_size=0.1, test_size=0.1)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "2024-11-19T10:14:31.912120+0100 WARNING Chromsizes file not provided. Will not check if regions are within chromosomes\n"
+     ]
+    }
+   ],
+   "source": [
+    "crested.pp.change_regions_width(adata, width=500)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Train tmp model"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "genome_path = \"/home/luna.kuleuven.be/u0166574/.local/share/genomes/mm10/mm10.fa\""
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "datamodule = crested.tl.data.AnnDataModule(\n",
+    "    adata,\n",
+    "    genome_file=genome_path,\n",
+    "    always_reverse_complement=False,\n",
+    "    batch_size=32,\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "model_arch = crested.tl.zoo.simple_convnet(\n",
+    "    seq_len=500,\n",
+    "    num_classes=len(list(adata.obs_names)),\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "configs = crested.tl.default_configs(\"peak_regression\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "trainer = crested.tl.Crested(\n",
+    "    data=datamodule,\n",
+    "    model=model_arch,\n",
+    "    config=configs,\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\"><span style=\"font-weight: bold\">Model: \"functional\"</span>\n",
+       "</pre>\n"
+      ],
+      "text/plain": [
+       "\u001b[1mModel: \"functional\"\u001b[0m\n"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/html": [
+       "<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\">┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━┓\n",
+       "┃<span style=\"font-weight: bold\"> Layer (type)                    </span>┃<span style=\"font-weight: bold\"> Output Shape           </span>┃<span style=\"font-weight: bold\">       Param # </span>┃\n",
+       "┡━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━┩\n",
+       "│ sequence (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">InputLayer</span>)           │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">500</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">4</span>)         │             <span style=\"color: #00af00; text-decoration-color: #00af00\">0</span> │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ conv1d (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">Conv1D</span>)                 │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">488</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">192</span>)       │        <span style=\"color: #00af00; text-decoration-color: #00af00\">10,176</span> │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ batch_normalization             │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">488</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">192</span>)       │           <span style=\"color: #00af00; text-decoration-color: #00af00\">768</span> │\n",
+       "│ (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">BatchNormalization</span>)            │                        │               │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ activation (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">Activation</span>)         │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">488</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">192</span>)       │             <span style=\"color: #00af00; text-decoration-color: #00af00\">0</span> │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ max_pooling1d (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">MaxPooling1D</span>)    │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">61</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">192</span>)        │             <span style=\"color: #00af00; text-decoration-color: #00af00\">0</span> │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ dropout (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">Dropout</span>)               │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">61</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">192</span>)        │             <span style=\"color: #00af00; text-decoration-color: #00af00\">0</span> │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ conv1d_1 (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">Conv1D</span>)               │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">55</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">256</span>)        │       <span style=\"color: #00af00; text-decoration-color: #00af00\">344,320</span> │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ batch_normalization_1           │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">55</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">256</span>)        │         <span style=\"color: #00af00; text-decoration-color: #00af00\">1,024</span> │\n",
+       "│ (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">BatchNormalization</span>)            │                        │               │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ activation_1 (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">Activation</span>)       │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">55</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">256</span>)        │             <span style=\"color: #00af00; text-decoration-color: #00af00\">0</span> │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ max_pooling1d_1 (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">MaxPooling1D</span>)  │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">27</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">256</span>)        │             <span style=\"color: #00af00; text-decoration-color: #00af00\">0</span> │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ dropout_1 (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">Dropout</span>)             │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">27</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">256</span>)        │             <span style=\"color: #00af00; text-decoration-color: #00af00\">0</span> │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ conv1d_2 (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">Conv1D</span>)               │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">21</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">512</span>)        │       <span style=\"color: #00af00; text-decoration-color: #00af00\">918,016</span> │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ batch_normalization_2           │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">21</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">512</span>)        │         <span style=\"color: #00af00; text-decoration-color: #00af00\">2,048</span> │\n",
+       "│ (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">BatchNormalization</span>)            │                        │               │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ activation_2 (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">Activation</span>)       │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">21</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">512</span>)        │             <span style=\"color: #00af00; text-decoration-color: #00af00\">0</span> │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ max_pooling1d_2 (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">MaxPooling1D</span>)  │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">10</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">512</span>)        │             <span style=\"color: #00af00; text-decoration-color: #00af00\">0</span> │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ dropout_2 (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">Dropout</span>)             │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">10</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">512</span>)        │             <span style=\"color: #00af00; text-decoration-color: #00af00\">0</span> │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ flatten (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">Flatten</span>)               │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">5120</span>)           │             <span style=\"color: #00af00; text-decoration-color: #00af00\">0</span> │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ dense (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">Dense</span>)                   │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">256</span>)            │     <span style=\"color: #00af00; text-decoration-color: #00af00\">1,310,976</span> │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ batch_normalization_3           │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">256</span>)            │         <span style=\"color: #00af00; text-decoration-color: #00af00\">1,024</span> │\n",
+       "│ (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">BatchNormalization</span>)            │                        │               │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ activation_3 (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">Activation</span>)       │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">256</span>)            │             <span style=\"color: #00af00; text-decoration-color: #00af00\">0</span> │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ dropout_3 (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">Dropout</span>)             │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">256</span>)            │             <span style=\"color: #00af00; text-decoration-color: #00af00\">0</span> │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ denseblock_dense (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">Dense</span>)        │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">8</span>)              │         <span style=\"color: #00af00; text-decoration-color: #00af00\">2,056</span> │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ denseblock_batchnorm            │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">8</span>)              │            <span style=\"color: #00af00; text-decoration-color: #00af00\">32</span> │\n",
+       "│ (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">BatchNormalization</span>)            │                        │               │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ denseblock_activation           │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">8</span>)              │             <span style=\"color: #00af00; text-decoration-color: #00af00\">0</span> │\n",
+       "│ (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">Activation</span>)                    │                        │               │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ denseblock_dropout (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">Dropout</span>)    │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">8</span>)              │             <span style=\"color: #00af00; text-decoration-color: #00af00\">0</span> │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ dense_out (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">Dense</span>)               │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">19</span>)             │           <span style=\"color: #00af00; text-decoration-color: #00af00\">171</span> │\n",
+       "└─────────────────────────────────┴────────────────────────┴───────────────┘\n",
+       "</pre>\n"
+      ],
+      "text/plain": [
+       "┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━┓\n",
+       "┃\u001b[1m \u001b[0m\u001b[1mLayer (type)                   \u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1mOutput Shape          \u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1m      Param #\u001b[0m\u001b[1m \u001b[0m┃\n",
+       "┡━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━┩\n",
+       "│ sequence (\u001b[38;5;33mInputLayer\u001b[0m)           │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m500\u001b[0m, \u001b[38;5;34m4\u001b[0m)         │             \u001b[38;5;34m0\u001b[0m │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ conv1d (\u001b[38;5;33mConv1D\u001b[0m)                 │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m488\u001b[0m, \u001b[38;5;34m192\u001b[0m)       │        \u001b[38;5;34m10,176\u001b[0m │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ batch_normalization             │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m488\u001b[0m, \u001b[38;5;34m192\u001b[0m)       │           \u001b[38;5;34m768\u001b[0m │\n",
+       "│ (\u001b[38;5;33mBatchNormalization\u001b[0m)            │                        │               │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ activation (\u001b[38;5;33mActivation\u001b[0m)         │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m488\u001b[0m, \u001b[38;5;34m192\u001b[0m)       │             \u001b[38;5;34m0\u001b[0m │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ max_pooling1d (\u001b[38;5;33mMaxPooling1D\u001b[0m)    │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m61\u001b[0m, \u001b[38;5;34m192\u001b[0m)        │             \u001b[38;5;34m0\u001b[0m │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ dropout (\u001b[38;5;33mDropout\u001b[0m)               │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m61\u001b[0m, \u001b[38;5;34m192\u001b[0m)        │             \u001b[38;5;34m0\u001b[0m │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ conv1d_1 (\u001b[38;5;33mConv1D\u001b[0m)               │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m55\u001b[0m, \u001b[38;5;34m256\u001b[0m)        │       \u001b[38;5;34m344,320\u001b[0m │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ batch_normalization_1           │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m55\u001b[0m, \u001b[38;5;34m256\u001b[0m)        │         \u001b[38;5;34m1,024\u001b[0m │\n",
+       "│ (\u001b[38;5;33mBatchNormalization\u001b[0m)            │                        │               │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ activation_1 (\u001b[38;5;33mActivation\u001b[0m)       │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m55\u001b[0m, \u001b[38;5;34m256\u001b[0m)        │             \u001b[38;5;34m0\u001b[0m │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ max_pooling1d_1 (\u001b[38;5;33mMaxPooling1D\u001b[0m)  │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m27\u001b[0m, \u001b[38;5;34m256\u001b[0m)        │             \u001b[38;5;34m0\u001b[0m │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ dropout_1 (\u001b[38;5;33mDropout\u001b[0m)             │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m27\u001b[0m, \u001b[38;5;34m256\u001b[0m)        │             \u001b[38;5;34m0\u001b[0m │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ conv1d_2 (\u001b[38;5;33mConv1D\u001b[0m)               │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m21\u001b[0m, \u001b[38;5;34m512\u001b[0m)        │       \u001b[38;5;34m918,016\u001b[0m │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ batch_normalization_2           │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m21\u001b[0m, \u001b[38;5;34m512\u001b[0m)        │         \u001b[38;5;34m2,048\u001b[0m │\n",
+       "│ (\u001b[38;5;33mBatchNormalization\u001b[0m)            │                        │               │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ activation_2 (\u001b[38;5;33mActivation\u001b[0m)       │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m21\u001b[0m, \u001b[38;5;34m512\u001b[0m)        │             \u001b[38;5;34m0\u001b[0m │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ max_pooling1d_2 (\u001b[38;5;33mMaxPooling1D\u001b[0m)  │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m10\u001b[0m, \u001b[38;5;34m512\u001b[0m)        │             \u001b[38;5;34m0\u001b[0m │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ dropout_2 (\u001b[38;5;33mDropout\u001b[0m)             │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m10\u001b[0m, \u001b[38;5;34m512\u001b[0m)        │             \u001b[38;5;34m0\u001b[0m │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ flatten (\u001b[38;5;33mFlatten\u001b[0m)               │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m5120\u001b[0m)           │             \u001b[38;5;34m0\u001b[0m │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ dense (\u001b[38;5;33mDense\u001b[0m)                   │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m256\u001b[0m)            │     \u001b[38;5;34m1,310,976\u001b[0m │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ batch_normalization_3           │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m256\u001b[0m)            │         \u001b[38;5;34m1,024\u001b[0m │\n",
+       "│ (\u001b[38;5;33mBatchNormalization\u001b[0m)            │                        │               │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ activation_3 (\u001b[38;5;33mActivation\u001b[0m)       │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m256\u001b[0m)            │             \u001b[38;5;34m0\u001b[0m │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ dropout_3 (\u001b[38;5;33mDropout\u001b[0m)             │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m256\u001b[0m)            │             \u001b[38;5;34m0\u001b[0m │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ denseblock_dense (\u001b[38;5;33mDense\u001b[0m)        │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m8\u001b[0m)              │         \u001b[38;5;34m2,056\u001b[0m │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ denseblock_batchnorm            │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m8\u001b[0m)              │            \u001b[38;5;34m32\u001b[0m │\n",
+       "│ (\u001b[38;5;33mBatchNormalization\u001b[0m)            │                        │               │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ denseblock_activation           │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m8\u001b[0m)              │             \u001b[38;5;34m0\u001b[0m │\n",
+       "│ (\u001b[38;5;33mActivation\u001b[0m)                    │                        │               │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ denseblock_dropout (\u001b[38;5;33mDropout\u001b[0m)    │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m8\u001b[0m)              │             \u001b[38;5;34m0\u001b[0m │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ dense_out (\u001b[38;5;33mDense\u001b[0m)               │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m19\u001b[0m)             │           \u001b[38;5;34m171\u001b[0m │\n",
+       "└─────────────────────────────────┴────────────────────────┴───────────────┘\n"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/html": [
+       "<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\"><span style=\"font-weight: bold\"> Total params: </span><span style=\"color: #00af00; text-decoration-color: #00af00\">2,590,611</span> (9.88 MB)\n",
+       "</pre>\n"
+      ],
+      "text/plain": [
+       "\u001b[1m Total params: \u001b[0m\u001b[38;5;34m2,590,611\u001b[0m (9.88 MB)\n"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/html": [
+       "<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\"><span style=\"font-weight: bold\"> Trainable params: </span><span style=\"color: #00af00; text-decoration-color: #00af00\">2,588,163</span> (9.87 MB)\n",
+       "</pre>\n"
+      ],
+      "text/plain": [
+       "\u001b[1m Trainable params: \u001b[0m\u001b[38;5;34m2,588,163\u001b[0m (9.87 MB)\n"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/html": [
+       "<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\"><span style=\"font-weight: bold\"> Non-trainable params: </span><span style=\"color: #00af00; text-decoration-color: #00af00\">2,448</span> (9.56 KB)\n",
+       "</pre>\n"
+      ],
+      "text/plain": [
+       "\u001b[1m Non-trainable params: \u001b[0m\u001b[38;5;34m2,448\u001b[0m (9.56 KB)\n"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "None\n",
+      "2024-11-19T10:14:32.309242+0100 INFO Loading sequences into memory...\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|██████████| 11469/11469 [00:01<00:00, 8285.45it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "2024-11-19T10:14:33.723510+0100 INFO Loading sequences into memory...\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|██████████| 1434/1434 [00:00<00:00, 7024.65it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\u001b[1m359/359\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m7s\u001b[0m 17ms/step - concordance_correlation_coefficient: 0.0240 - cosine_similarity: 0.4381 - loss: 12.7993 - mean_absolute_error: 0.5750 - mean_squared_error: 0.4554 - pearson_correlation: 0.0880 - pearson_correlation_log: 0.0953 - zero_penalty_metric: 706.3998 - val_concordance_correlation_coefficient: 0.1166 - val_cosine_similarity: 0.4350 - val_loss: 8.9342 - val_mean_absolute_error: 0.3070 - val_mean_squared_error: 0.2468 - val_pearson_correlation: 0.2148 - val_pearson_correlation_log: 0.1193 - val_zero_penalty_metric: 634.5710 - learning_rate: 0.0010\n"
+     ]
+    }
+   ],
+   "source": [
+    "trainer.fit(\n",
+    "    epochs=1,\n",
+    "    model_checkpointing=False,\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\u001b[1m45/45\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 11ms/step - concordance_correlation_coefficient: 0.1178 - cosine_similarity: 0.4357 - loss: 8.3975 - mean_absolute_error: 0.3113 - mean_squared_error: 0.2824 - pearson_correlation: 0.2278 - pearson_correlation_log: 0.1264 - zero_penalty_metric: 588.5892\n",
+      "2024-11-19T10:14:41.094942+0100 INFO Test concordance_correlation_coefficient: 0.1115\n"
+     ]
+    }
+   ],
+   "source": [
+    "trainer.test()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "['ATTACTACTCCCAGAGTGTCCAATAACTAGCTCAAGGTTGCCTGGCCAGGTAGCTGTCCAACCAAGGTGCTTTTCTTCGTTCAACCTATTCCAAACTTTTCACTCCATAAGGACCTCCACATGTGCCACCAGTGTTGACATTCTACCACTTGAGACCATCTTTTACTCATCCCTTAATTTAACCACCCTTTTCACTGTCATGCTTAGTTGTCTCAGCAGCAACCTTCTTTGAGAACACTGCCCAAAGAGGAAAGTGTAAAAATGAACCATTGTTTAAGCCCCAATTTTATTTTTTCACAAAAACTAATGATGGTTGGCTTACCCCTTCTTTTCTAACCATTTTGAGAGACATATTAGATTCCCACATAAACCTATCATAAAGGTTAAAAGTTAATGATCTCTTCCTGAATATCCTTATTGTGAAGAAAAGCTTTCCAGGACACTCATCAGCTGCTCTTTCTAGTCAATGCCATGTCTTTTACCAACAGTGCCTGACAAAG']"
+      ]
+     },
+     "execution_count": 15,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "crested.utils.fetch_sequences(\"chr4:91209533-91210033\", genome_path)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Start from here"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import anndata\n",
+    "\n",
+    "import crested"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "anndata_path = (\n",
+    "    \"/home/luna.kuleuven.be/u0166574/Desktop/data/biccn/mouse_biccn_data_filtered.h5ad\"\n",
+    ")\n",
+    "model_path = \"/home/luna.kuleuven.be/u0166574/Desktop/data/biccn/BICCN_model.keras\"\n",
+    "genome_path = \"/home/luna.kuleuven.be/u0166574/.local/share/genomes/mm10/mm10.fa\"\n",
+    "bigwigs = \"/home/luna.kuleuven.be/u0166574/.cache/crested/data/mouse_biccn/bigwigs.tar.gz.untar\""
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 19,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "adata = anndata.read_h5ad(anndata_path)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 20,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "datamodule = crested.tl.data.AnnDataModule(\n",
+    "    adata, genome_file=genome_path, batch_size=32\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "2024-11-19T11:11:45.832406+0100 WARNING No GPUs available, falling back to CPU.\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "2024-11-19 11:11:45.830515: E external/local_xla/xla/stream_executor/cuda/cuda_driver.cc:152] failed call to cuInit: INTERNAL: CUDA error: Failed call to cuInit: CUDA_ERROR_NO_DEVICE: no CUDA-capable device is detected\n",
+      "2024-11-19 11:11:45.830535: I external/local_xla/xla/stream_executor/cuda/cuda_diagnostics.cc:137] retrieving CUDA diagnostic information for host: gbw-l-l0080\n",
+      "2024-11-19 11:11:45.830539: I external/local_xla/xla/stream_executor/cuda/cuda_diagnostics.cc:144] hostname: gbw-l-l0080\n",
+      "2024-11-19 11:11:45.830675: I external/local_xla/xla/stream_executor/cuda/cuda_diagnostics.cc:168] libcuda reported version is: 555.42.6\n",
+      "2024-11-19 11:11:45.830686: I external/local_xla/xla/stream_executor/cuda/cuda_diagnostics.cc:172] kernel reported version is: 555.42.6\n",
+      "2024-11-19 11:11:45.830688: I external/local_xla/xla/stream_executor/cuda/cuda_diagnostics.cc:259] kernel version seems to match DSO: 555.42.6\n"
+     ]
+    }
+   ],
+   "source": [
+    "trainer = crested.tl.Crested(data=datamodule)\n",
+    "trainer.load_model(model_path)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "%matplotlib inline\n",
+    "chrom = \"chr4\"\n",
+    "start = 91209533\n",
+    "end = 91211647\n",
+    "\n",
+    "scores, coordinates, min_loc, max_loc, tss_position = trainer.score_gene_locus(\n",
+    "    chr_name=chrom,\n",
+    "    gene_start=start,\n",
+    "    gene_end=end,\n",
+    "    class_name=\"Sst\",\n",
+    "    strand=\"-\",\n",
+    "    upstream=5000,\n",
+    "    downstream=5000,\n",
+    "    step_size=500,\n",
+    "    window_size=2114,\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "(91204533, 91216647, 91211647)"
+      ]
+     },
+     "execution_count": 14,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "min_loc, max_loc, tss_position"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "coordinates = (chrom, min_loc, max_loc)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "91216647"
+      ]
+     },
+     "execution_count": 16,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "coordinates[2]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 21,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "bw_values, midpoints = crested.utils.read_bigwig_region(\n",
+    "    f\"{bigwigs}/Sst.bw\", coordinates=coordinates\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 22,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 3000x1000 with 2 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "%matplotlib inline\n",
+    "crested.pl.hist.locus_scoring(\n",
+    "    scores,\n",
+    "    (min_loc, max_loc),\n",
+    "    gene_start=start,\n",
+    "    gene_end=end,\n",
+    "    bigwig_values=bw_values,\n",
+    "    bigwig_midpoints=midpoints,\n",
+    "    height=10,\n",
+    "    width=30,\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 23,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "2024-11-19T11:15:46.995714+0100 INFO After sorting and filtering, kept 19000 regions.\n"
+     ]
+    }
+   ],
+   "source": [
+    "crested.pp.sort_and_filter_regions_on_specificity(adata, top_k=1000)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 24,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "Index(['Astro', 'Endo', 'L2_3IT', 'L5ET', 'L5IT', 'L5_6NP', 'L6CT', 'L6IT',\n",
+       "       'L6b', 'Lamp5', 'Micro_PVM', 'OPC', 'Oligo', 'Pvalb', 'Sncg', 'Sst',\n",
+       "       'SstChodl', 'VLMC', 'Vip'],\n",
+       "      dtype='object')"
+      ]
+     },
+     "execution_count": 24,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "adata.obs_names"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 26,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "2024-11-19T11:16:06.469591+0100 INFO Found 'Class name' column in adata.var. Using specific regions per class to calculate contribution scores.\n",
+      "2024-11-19T11:16:06.498659+0100 INFO Calculating contribution scores for 1 class(es) and 1000 region(s).\n"
+     ]
+    },
+    {
+     "ename": "KeyboardInterrupt",
+     "evalue": "",
+     "output_type": "error",
+     "traceback": [
+      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
+      "\u001b[0;31mKeyboardInterrupt\u001b[0m                         Traceback (most recent call last)",
+      "\u001b[0;32m/tmp/ipykernel_45203/4071556197.py\u001b[0m in \u001b[0;36m?\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m trainer.tfmodisco_calculate_and_save_contribution_scores(\n\u001b[0m\u001b[1;32m      2\u001b[0m     \u001b[0madata\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      3\u001b[0m     \u001b[0moutput_dir\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m\"modisco_results\"\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      4\u001b[0m     \u001b[0mclass_names\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m\"Astro\"\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+      "\u001b[0;32m~/Desktop/projects/CREsted/src/crested/tl/_crested.py\u001b[0m in \u001b[0;36m?\u001b[0;34m(self, adata, output_dir, method, class_names)\u001b[0m\n\u001b[1;32m   1309\u001b[0m             \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1310\u001b[0m                 \u001b[0mclass_regions\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0madata\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mvar\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mindex\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtolist\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1311\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1312\u001b[0m             \u001b[0;31m# Calculate contribution scores for the regions of the current class\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1313\u001b[0;31m             contrib_scores, one_hot_seqs = self.calculate_contribution_scores_regions(\n\u001b[0m\u001b[1;32m   1314\u001b[0m                 \u001b[0mregion_idx\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mclass_regions\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1315\u001b[0m                 \u001b[0mclass_names\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mclass_name\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1316\u001b[0m                 \u001b[0mmethod\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mmethod\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+      "\u001b[0;32m~/Desktop/projects/CREsted/src/crested/tl/_crested.py\u001b[0m in \u001b[0;36m?\u001b[0;34m(self, region_idx, class_names, method, disable_tqdm)\u001b[0m\n\u001b[1;32m   1004\u001b[0m         \u001b[0;32mfor\u001b[0m \u001b[0mregion\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mregion_idx\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1005\u001b[0m             sequences.append(\n\u001b[1;32m   1006\u001b[0m                 \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0manndatamodule\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mpredict_dataset\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msequence_loader\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mget_sequence\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mregion\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1007\u001b[0m             \u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1008\u001b[0;31m         return self.calculate_contribution_scores_sequence(\n\u001b[0m\u001b[1;32m   1009\u001b[0m             \u001b[0msequences\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0msequences\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1010\u001b[0m             \u001b[0mclass_names\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mclass_names\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1011\u001b[0m             \u001b[0mmethod\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mmethod\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+      "\u001b[0;32m~/Desktop/projects/CREsted/src/crested/tl/_crested.py\u001b[0m in \u001b[0;36m?\u001b[0;34m(self, sequences, class_names, method, disable_tqdm)\u001b[0m\n\u001b[1;32m   1087\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1088\u001b[0m             \u001b[0;32mfor\u001b[0m \u001b[0mi\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mclass_index\u001b[0m \u001b[0;32min\u001b[0m \u001b[0menumerate\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mclass_indices\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1089\u001b[0m                 \u001b[0mexplainer\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mExplainer\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmodel\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mclass_index\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mclass_index\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1090\u001b[0m                 \u001b[0;32mif\u001b[0m \u001b[0mmethod\u001b[0m \u001b[0;34m==\u001b[0m \u001b[0;34m\"integrated_grad\"\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1091\u001b[0;31m                     scores[:, i, :, :] = explainer.integrated_grad(\n\u001b[0m\u001b[1;32m   1092\u001b[0m                         \u001b[0mx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mbaseline_type\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m\"zeros\"\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1093\u001b[0m                     \u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1094\u001b[0m                 \u001b[0;32melif\u001b[0m \u001b[0mmethod\u001b[0m \u001b[0;34m==\u001b[0m \u001b[0;34m\"mutagenesis\"\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+      "\u001b[0;32m~/Desktop/projects/CREsted/src/crested/tl/_explainer_tf.py\u001b[0m in \u001b[0;36m?\u001b[0;34m(self, X, baseline_type, num_steps)\u001b[0m\n\u001b[1;32m     49\u001b[0m         \u001b[0mscores\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     50\u001b[0m         \u001b[0;32mfor\u001b[0m \u001b[0mx\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mX\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     51\u001b[0m             \u001b[0mx\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mexpand_dims\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0maxis\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     52\u001b[0m             \u001b[0mbaseline\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mset_baseline\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mbaseline_type\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mnum_samples\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 53\u001b[0;31m             intgrad_scores = integrated_grad(\n\u001b[0m\u001b[1;32m     54\u001b[0m                 \u001b[0mx\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     55\u001b[0m                 \u001b[0mmodel\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmodel\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     56\u001b[0m                 \u001b[0mbaseline\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mbaseline\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+      "\u001b[0;32m~/Desktop/projects/CREsted/src/crested/tl/_explainer_tf.py\u001b[0m in \u001b[0;36m?\u001b[0;34m(x, model, baseline, num_steps, class_index, func)\u001b[0m\n\u001b[1;32m    165\u001b[0m         \u001b[0;32mreturn\u001b[0m \u001b[0mx\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    166\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    167\u001b[0m     \u001b[0msteps\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtf\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlinspace\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mstart\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m0.0\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mstop\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m1.0\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mnum\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mnum_steps\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0;36m1\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    168\u001b[0m     \u001b[0mx_interp\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0minterpolate_data\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mbaseline\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0msteps\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 169\u001b[0;31m     \u001b[0mgrad\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0msaliency_map\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx_interp\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmodel\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mclass_index\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mclass_index\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfunc\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mfunc\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    170\u001b[0m     \u001b[0mavg_grad\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mintegral_approximation\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mgrad\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    171\u001b[0m     \u001b[0mavg_grad\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mexpand_dims\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mavg_grad\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0maxis\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    172\u001b[0m     \u001b[0;32mreturn\u001b[0m \u001b[0mavg_grad\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+      "\u001b[0;32m~/Desktop/projects/CREsted/src/crested/tl/_explainer_tf.py\u001b[0m in \u001b[0;36m?\u001b[0;34m(X, model, class_index, func)\u001b[0m\n\u001b[1;32m    107\u001b[0m         \u001b[0;32mif\u001b[0m \u001b[0mclass_index\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    108\u001b[0m             \u001b[0moutputs\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmodel\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mX\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mclass_index\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    109\u001b[0m         \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    110\u001b[0m             \u001b[0moutputs\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mfunc\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mmodel\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mX\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 111\u001b[0;31m     \u001b[0;32mreturn\u001b[0m \u001b[0mtape\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mgradient\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0moutputs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mX\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
+      "\u001b[0;32m~/miniconda3/envs/crested_dev/lib/python3.12/site-packages/tensorflow/python/eager/backprop.py\u001b[0m in \u001b[0;36m?\u001b[0;34m(self, target, sources, output_gradients, unconnected_gradients)\u001b[0m\n\u001b[1;32m   1062\u001b[0m               \u001b[0moutput_gradients\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1063\u001b[0m       output_gradients = [None if x is None else ops.convert_to_tensor(x)\n\u001b[1;32m   1064\u001b[0m                           \u001b[0;32mfor\u001b[0m \u001b[0mx\u001b[0m \u001b[0;32min\u001b[0m \u001b[0moutput_gradients\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1065\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1066\u001b[0;31m     flat_grad = imperative_grad.imperative_grad(\n\u001b[0m\u001b[1;32m   1067\u001b[0m         \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_tape\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1068\u001b[0m         \u001b[0mflat_targets\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1069\u001b[0m         \u001b[0mflat_sources\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+      "\u001b[0;32m~/miniconda3/envs/crested_dev/lib/python3.12/site-packages/tensorflow/python/eager/imperative_grad.py\u001b[0m in \u001b[0;36m?\u001b[0;34m(tape, target, sources, output_gradients, sources_raw, unconnected_gradients)\u001b[0m\n\u001b[1;32m     63\u001b[0m   \u001b[0;32mexcept\u001b[0m \u001b[0mValueError\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     64\u001b[0m     raise ValueError(\n\u001b[1;32m     65\u001b[0m         \u001b[0;34m\"Unknown value for unconnected_gradients: %r\"\u001b[0m \u001b[0;34m%\u001b[0m \u001b[0munconnected_gradients\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     66\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 67\u001b[0;31m   return pywrap_tfe.TFE_Py_TapeGradient(\n\u001b[0m\u001b[1;32m     68\u001b[0m       \u001b[0mtape\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_tape\u001b[0m\u001b[0;34m,\u001b[0m  \u001b[0;31m# pylint: disable=protected-access\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     69\u001b[0m       \u001b[0mtarget\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     70\u001b[0m       \u001b[0msources\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+      "\u001b[0;32m~/miniconda3/envs/crested_dev/lib/python3.12/site-packages/tensorflow/python/eager/backprop.py\u001b[0m in \u001b[0;36m?\u001b[0;34m(op_name, attr_tuple, num_inputs, inputs, outputs, out_grads, skip_input_indices, forward_pass_name_scope)\u001b[0m\n\u001b[1;32m    144\u001b[0m     \u001b[0mgradient_name_scope\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m\"gradient_tape/\"\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    145\u001b[0m     \u001b[0;32mif\u001b[0m \u001b[0mforward_pass_name_scope\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    146\u001b[0m       \u001b[0mgradient_name_scope\u001b[0m \u001b[0;34m+=\u001b[0m \u001b[0mforward_pass_name_scope\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0;34m\"/\"\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    147\u001b[0m     \u001b[0;32mwith\u001b[0m \u001b[0mops\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mname_scope\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mgradient_name_scope\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 148\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mgrad_fn\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mmock_op\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0mout_grads\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    149\u001b[0m   \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    150\u001b[0m     \u001b[0;32mreturn\u001b[0m \u001b[0mgrad_fn\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mmock_op\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0mout_grads\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+      "\u001b[0;32m~/miniconda3/envs/crested_dev/lib/python3.12/site-packages/tensorflow/python/ops/nn_grad.py\u001b[0m in \u001b[0;36m?\u001b[0;34m(op, grad)\u001b[0m\n\u001b[1;32m    590\u001b[0m           \u001b[0mpadding\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mpadding\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    591\u001b[0m           \u001b[0mexplicit_paddings\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mexplicit_paddings\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    592\u001b[0m           \u001b[0muse_cudnn_on_gpu\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0muse_cudnn_on_gpu\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    593\u001b[0m           \u001b[0mdata_format\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mdata_format\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 594\u001b[0;31m       gen_nn_ops.conv2d_backprop_filter(\n\u001b[0m\u001b[1;32m    595\u001b[0m           \u001b[0mop\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0minputs\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    596\u001b[0m           \u001b[0mshape_1\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    597\u001b[0m           \u001b[0mgrad\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+      "\u001b[0;32m~/miniconda3/envs/crested_dev/lib/python3.12/site-packages/tensorflow/python/ops/gen_nn_ops.py\u001b[0m in \u001b[0;36m?\u001b[0;34m(input, filter_sizes, out_backprop, strides, padding, use_cudnn_on_gpu, explicit_paddings, data_format, dilations, name)\u001b[0m\n\u001b[1;32m   1495\u001b[0m         \u001b[0mdata_format\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m\"dilations\"\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdilations\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1496\u001b[0m       \u001b[0;32mreturn\u001b[0m \u001b[0m_result\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1497\u001b[0m     \u001b[0;32mexcept\u001b[0m \u001b[0m_core\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_NotOkStatusException\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0me\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1498\u001b[0m       \u001b[0m_ops\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mraise_from_not_ok_status\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0me\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mname\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1499\u001b[0;31m     \u001b[0;32mexcept\u001b[0m \u001b[0m_core\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_FallbackException\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1500\u001b[0m       \u001b[0;32mpass\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1501\u001b[0m     \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1502\u001b[0m       return conv2d_backprop_filter_eager_fallback(\n",
+      "\u001b[0;31mKeyboardInterrupt\u001b[0m: "
+     ]
+    }
+   ],
+   "source": [
+    "trainer.tfmodisco_calculate_and_save_contribution_scores(\n",
+    "    adata, output_dir=\"modisco_results\", class_names=[\"Astro\"], method=\"integrated_grad\"\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 35,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "2024-11-19T10:27:37.279986+0100 INFO No class names provided, using all found in the contribution directory: ['Astro']\n",
+      "2024-11-19T10:27:37.350093+0100 INFO Running modisco for class: Astro\n",
+      "Using 245 positive seqlets\n"
+     ]
+    }
+   ],
+   "source": [
+    "crested.tl.modisco.tfmodisco(\n",
+    "    window=100,\n",
+    "    output_dir=\"modisco_results\",\n",
+    "    contrib_dir=\"modisco_results\",\n",
+    "    report=False,\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 42,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "2024-11-19T10:32:20.571699+0100 INFO Starting genomic contributions plot for classes: ['Astro']\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 600x800 with 4 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "crested.pl.patterns.modisco_results(\n",
+    "    classes=[\"Astro\"],\n",
+    "    contribution=\"positive\",\n",
+    "    contribution_dir=\"modisco_results\",\n",
+    "    num_seq=1000,\n",
+    "    y_max=0.15,\n",
+    "    viz=\"contrib\",\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# First we obtain the resulting modisco files per class\n",
+    "matched_files = crested.tl.modisco.match_h5_files_to_classes(\n",
+    "    contribution_dir=\"modisco_results\", classes=[\"Astro\"]\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Reading file modisco_results/Astro_modisco_results.h5\n",
+      "Warning: TOMTOM error while comparing patterns Astro_pos_patterns_1 and Astro_pos_patterns_0. Returning no match.\n",
+      "Error details: Failed in nopython mode pipeline (step: nopython frontend)\n",
+      "\u001b[1m\u001b[1m\u001b[1m\u001b[1mFailed in nopython mode pipeline (step: nopython frontend)\n",
+      "\u001b[1m\u001b[1mNo implementation of function Function(<built-in function iadd>) found for signature:\n",
+      " \n",
+      " >>> iadd(Literal[int](0), array(int32, 1d, C))\n",
+      " \n",
+      "There are 18 candidate implementations:\n",
+      "\u001b[1m     - Of which 16 did not match due to:\n",
+      "     Overload of function 'iadd': File: <numerous>: Line N/A.\n",
+      "       With argument(s): '(int64, array(int32, 1d, C))':\u001b[0m\n",
+      "\u001b[1m      No match.\u001b[0m\n",
+      "\u001b[1m     - Of which 2 did not match due to:\n",
+      "     Operator Overload in function 'iadd': File: unknown: Line unknown.\n",
+      "       With argument(s): '(int64, array(int32, 1d, C))':\u001b[0m\n",
+      "\u001b[1m      No match for registered cases:\n",
+      "       * (int64, int64) -> int64\n",
+      "       * (int64, uint64) -> int64\n",
+      "       * (uint64, int64) -> int64\n",
+      "       * (uint64, uint64) -> uint64\n",
+      "       * (float32, float32) -> float32\n",
+      "       * (float64, float64) -> float64\n",
+      "       * (complex64, complex64) -> complex64\n",
+      "       * (complex128, complex128) -> complex128\u001b[0m\n",
+      "\u001b[0m\n",
+      "\u001b[0m\u001b[1mDuring: typing of intrinsic-call at /home/luna.kuleuven.be/u0166574/miniconda3/envs/crested_dev_torch/lib/python3.12/site-packages/tangermeme/tools/tomtom.py (242)\u001b[0m\n",
+      "\u001b[1m\n",
+      "File \"../../../miniconda3/envs/crested_dev_torch/lib/python3.12/site-packages/tangermeme/tools/tomtom.py\", line 242:\u001b[0m\n",
+      "\u001b[1mdef _p_values(gamma, B_cdfs, rr_inv, T_lens, nq, offset, n_bins, results):\n",
+      "    <source elided>\n",
+      "\t\t\t\t\tj, t_idx = uint64(j), uint64(total_offset + j + k)\n",
+      "\u001b[1m\t\t\t\t\tscore += gamma[j, rr_inv[t_idx]]\n",
+      "\u001b[0m     \u001b[1m^\u001b[0m\u001b[0m\n",
+      "\n",
+      "\u001b[0m\u001b[1mDuring: resolving callee type: type(CPUDispatcher(<function _p_values at 0x709694269f80>))\u001b[0m\n",
+      "\u001b[0m\u001b[1mDuring: typing of call at /home/luna.kuleuven.be/u0166574/miniconda3/envs/crested_dev_torch/lib/python3.12/site-packages/tangermeme/tools/tomtom.py (341)\n",
+      "\u001b[0m\n",
+      "\u001b[0m\u001b[1mDuring: resolving callee type: type(CPUDispatcher(<function _p_values at 0x709694269f80>))\u001b[0m\n",
+      "\u001b[0m\u001b[1mDuring: typing of call at /home/luna.kuleuven.be/u0166574/miniconda3/envs/crested_dev_torch/lib/python3.12/site-packages/tangermeme/tools/tomtom.py (341)\n",
+      "\u001b[0m\n",
+      "\u001b[1m\n",
+      "File \"../../../miniconda3/envs/crested_dev_torch/lib/python3.12/site-packages/tangermeme/tools/tomtom.py\", line 341:\u001b[0m\n",
+      "\u001b[1mdef _tomtom(Q, T, Q_lens, T_lens, Q_norm, T_norm, rr_inv, rr_counts, n_nearest, \n",
+      "    <source elided>\n",
+      "\n",
+      "\u001b[1m\t\t_p_values(_gamma[pid], _B[pid], rr_inv, T_lens, nq, offset, \n",
+      "\u001b[0m  \u001b[1m^\u001b[0m\u001b[0m\n",
+      "\n",
+      "Warning: TOMTOM error while comparing patterns Astro_pos_patterns_2 and Astro_pos_patterns_0. Returning no match.\n",
+      "Error details: Failed in nopython mode pipeline (step: nopython frontend)\n",
+      "\u001b[1m\u001b[1m\u001b[1m\u001b[1mFailed in nopython mode pipeline (step: nopython frontend)\n",
+      "\u001b[1m\u001b[1mNo implementation of function Function(<built-in function iadd>) found for signature:\n",
+      " \n",
+      " >>> iadd(Literal[int](0), array(int32, 1d, C))\n",
+      " \n",
+      "There are 18 candidate implementations:\n",
+      "\u001b[1m     - Of which 16 did not match due to:\n",
+      "     Overload of function 'iadd': File: <numerous>: Line N/A.\n",
+      "       With argument(s): '(int64, array(int32, 1d, C))':\u001b[0m\n",
+      "\u001b[1m      No match.\u001b[0m\n",
+      "\u001b[1m     - Of which 2 did not match due to:\n",
+      "     Operator Overload in function 'iadd': File: unknown: Line unknown.\n",
+      "       With argument(s): '(int64, array(int32, 1d, C))':\u001b[0m\n",
+      "\u001b[1m      No match for registered cases:\n",
+      "       * (int64, int64) -> int64\n",
+      "       * (int64, uint64) -> int64\n",
+      "       * (uint64, int64) -> int64\n",
+      "       * (uint64, uint64) -> uint64\n",
+      "       * (float32, float32) -> float32\n",
+      "       * (float64, float64) -> float64\n",
+      "       * (complex64, complex64) -> complex64\n",
+      "       * (complex128, complex128) -> complex128\u001b[0m\n",
+      "\u001b[0m\n",
+      "\u001b[0m\u001b[1mDuring: typing of intrinsic-call at /home/luna.kuleuven.be/u0166574/miniconda3/envs/crested_dev_torch/lib/python3.12/site-packages/tangermeme/tools/tomtom.py (242)\u001b[0m\n",
+      "\u001b[1m\n",
+      "File \"../../../miniconda3/envs/crested_dev_torch/lib/python3.12/site-packages/tangermeme/tools/tomtom.py\", line 242:\u001b[0m\n",
+      "\u001b[1mdef _p_values(gamma, B_cdfs, rr_inv, T_lens, nq, offset, n_bins, results):\n",
+      "    <source elided>\n",
+      "\t\t\t\t\tj, t_idx = uint64(j), uint64(total_offset + j + k)\n",
+      "\u001b[1m\t\t\t\t\tscore += gamma[j, rr_inv[t_idx]]\n",
+      "\u001b[0m     \u001b[1m^\u001b[0m\u001b[0m\n",
+      "\n",
+      "\u001b[0m\u001b[1mDuring: resolving callee type: type(CPUDispatcher(<function _p_values at 0x709694269f80>))\u001b[0m\n",
+      "\u001b[0m\u001b[1mDuring: typing of call at /home/luna.kuleuven.be/u0166574/miniconda3/envs/crested_dev_torch/lib/python3.12/site-packages/tangermeme/tools/tomtom.py (341)\n",
+      "\u001b[0m\n",
+      "\u001b[0m\u001b[1mDuring: resolving callee type: type(CPUDispatcher(<function _p_values at 0x709694269f80>))\u001b[0m\n",
+      "\u001b[0m\u001b[1mDuring: typing of call at /home/luna.kuleuven.be/u0166574/miniconda3/envs/crested_dev_torch/lib/python3.12/site-packages/tangermeme/tools/tomtom.py (341)\n",
+      "\u001b[0m\n",
+      "\u001b[1m\n",
+      "File \"../../../miniconda3/envs/crested_dev_torch/lib/python3.12/site-packages/tangermeme/tools/tomtom.py\", line 341:\u001b[0m\n",
+      "\u001b[1mdef _tomtom(Q, T, Q_lens, T_lens, Q_norm, T_norm, rr_inv, rr_counts, n_nearest, \n",
+      "    <source elided>\n",
+      "\n",
+      "\u001b[1m\t\t_p_values(_gamma[pid], _B[pid], rr_inv, T_lens, nq, offset, \n",
+      "\u001b[0m  \u001b[1m^\u001b[0m\u001b[0m\n",
+      "\n",
+      "Warning: TOMTOM error while comparing patterns Astro_pos_patterns_2 and Astro_pos_patterns_1. Returning no match.\n",
+      "Error details: Failed in nopython mode pipeline (step: nopython frontend)\n",
+      "\u001b[1m\u001b[1m\u001b[1m\u001b[1mFailed in nopython mode pipeline (step: nopython frontend)\n",
+      "\u001b[1m\u001b[1mNo implementation of function Function(<built-in function iadd>) found for signature:\n",
+      " \n",
+      " >>> iadd(Literal[int](0), array(int32, 1d, C))\n",
+      " \n",
+      "There are 18 candidate implementations:\n",
+      "\u001b[1m     - Of which 16 did not match due to:\n",
+      "     Overload of function 'iadd': File: <numerous>: Line N/A.\n",
+      "       With argument(s): '(int64, array(int32, 1d, C))':\u001b[0m\n",
+      "\u001b[1m      No match.\u001b[0m\n",
+      "\u001b[1m     - Of which 2 did not match due to:\n",
+      "     Operator Overload in function 'iadd': File: unknown: Line unknown.\n",
+      "       With argument(s): '(int64, array(int32, 1d, C))':\u001b[0m\n",
+      "\u001b[1m      No match for registered cases:\n",
+      "       * (int64, int64) -> int64\n",
+      "       * (int64, uint64) -> int64\n",
+      "       * (uint64, int64) -> int64\n",
+      "       * (uint64, uint64) -> uint64\n",
+      "       * (float32, float32) -> float32\n",
+      "       * (float64, float64) -> float64\n",
+      "       * (complex64, complex64) -> complex64\n",
+      "       * (complex128, complex128) -> complex128\u001b[0m\n",
+      "\u001b[0m\n",
+      "\u001b[0m\u001b[1mDuring: typing of intrinsic-call at /home/luna.kuleuven.be/u0166574/miniconda3/envs/crested_dev_torch/lib/python3.12/site-packages/tangermeme/tools/tomtom.py (242)\u001b[0m\n",
+      "\u001b[1m\n",
+      "File \"../../../miniconda3/envs/crested_dev_torch/lib/python3.12/site-packages/tangermeme/tools/tomtom.py\", line 242:\u001b[0m\n",
+      "\u001b[1mdef _p_values(gamma, B_cdfs, rr_inv, T_lens, nq, offset, n_bins, results):\n",
+      "    <source elided>\n",
+      "\t\t\t\t\tj, t_idx = uint64(j), uint64(total_offset + j + k)\n",
+      "\u001b[1m\t\t\t\t\tscore += gamma[j, rr_inv[t_idx]]\n",
+      "\u001b[0m     \u001b[1m^\u001b[0m\u001b[0m\n",
+      "\n",
+      "\u001b[0m\u001b[1mDuring: resolving callee type: type(CPUDispatcher(<function _p_values at 0x709694269f80>))\u001b[0m\n",
+      "\u001b[0m\u001b[1mDuring: typing of call at /home/luna.kuleuven.be/u0166574/miniconda3/envs/crested_dev_torch/lib/python3.12/site-packages/tangermeme/tools/tomtom.py (341)\n",
+      "\u001b[0m\n",
+      "\u001b[0m\u001b[1mDuring: resolving callee type: type(CPUDispatcher(<function _p_values at 0x709694269f80>))\u001b[0m\n",
+      "\u001b[0m\u001b[1mDuring: typing of call at /home/luna.kuleuven.be/u0166574/miniconda3/envs/crested_dev_torch/lib/python3.12/site-packages/tangermeme/tools/tomtom.py (341)\n",
+      "\u001b[0m\n",
+      "\u001b[1m\n",
+      "File \"../../../miniconda3/envs/crested_dev_torch/lib/python3.12/site-packages/tangermeme/tools/tomtom.py\", line 341:\u001b[0m\n",
+      "\u001b[1mdef _tomtom(Q, T, Q_lens, T_lens, Q_norm, T_norm, rr_inv, rr_counts, n_nearest, \n",
+      "    <source elided>\n",
+      "\n",
+      "\u001b[1m\t\t_p_values(_gamma[pid], _B[pid], rr_inv, T_lens, nq, offset, \n",
+      "\u001b[0m  \u001b[1m^\u001b[0m\u001b[0m\n",
+      "\n",
+      "Warning: TOMTOM error while comparing patterns Astro_pos_patterns_3 and Astro_pos_patterns_0. Returning no match.\n",
+      "Error details: Failed in nopython mode pipeline (step: nopython frontend)\n",
+      "\u001b[1m\u001b[1m\u001b[1m\u001b[1mFailed in nopython mode pipeline (step: nopython frontend)\n",
+      "\u001b[1m\u001b[1mNo implementation of function Function(<built-in function iadd>) found for signature:\n",
+      " \n",
+      " >>> iadd(Literal[int](0), array(int32, 1d, C))\n",
+      " \n",
+      "There are 18 candidate implementations:\n",
+      "\u001b[1m     - Of which 16 did not match due to:\n",
+      "     Overload of function 'iadd': File: <numerous>: Line N/A.\n",
+      "       With argument(s): '(int64, array(int32, 1d, C))':\u001b[0m\n",
+      "\u001b[1m      No match.\u001b[0m\n",
+      "\u001b[1m     - Of which 2 did not match due to:\n",
+      "     Operator Overload in function 'iadd': File: unknown: Line unknown.\n",
+      "       With argument(s): '(int64, array(int32, 1d, C))':\u001b[0m\n",
+      "\u001b[1m      No match for registered cases:\n",
+      "       * (int64, int64) -> int64\n",
+      "       * (int64, uint64) -> int64\n",
+      "       * (uint64, int64) -> int64\n",
+      "       * (uint64, uint64) -> uint64\n",
+      "       * (float32, float32) -> float32\n",
+      "       * (float64, float64) -> float64\n",
+      "       * (complex64, complex64) -> complex64\n",
+      "       * (complex128, complex128) -> complex128\u001b[0m\n",
+      "\u001b[0m\n",
+      "\u001b[0m\u001b[1mDuring: typing of intrinsic-call at /home/luna.kuleuven.be/u0166574/miniconda3/envs/crested_dev_torch/lib/python3.12/site-packages/tangermeme/tools/tomtom.py (242)\u001b[0m\n",
+      "\u001b[1m\n",
+      "File \"../../../miniconda3/envs/crested_dev_torch/lib/python3.12/site-packages/tangermeme/tools/tomtom.py\", line 242:\u001b[0m\n",
+      "\u001b[1mdef _p_values(gamma, B_cdfs, rr_inv, T_lens, nq, offset, n_bins, results):\n",
+      "    <source elided>\n",
+      "\t\t\t\t\tj, t_idx = uint64(j), uint64(total_offset + j + k)\n",
+      "\u001b[1m\t\t\t\t\tscore += gamma[j, rr_inv[t_idx]]\n",
+      "\u001b[0m     \u001b[1m^\u001b[0m\u001b[0m\n",
+      "\n",
+      "\u001b[0m\u001b[1mDuring: resolving callee type: type(CPUDispatcher(<function _p_values at 0x709694269f80>))\u001b[0m\n",
+      "\u001b[0m\u001b[1mDuring: typing of call at /home/luna.kuleuven.be/u0166574/miniconda3/envs/crested_dev_torch/lib/python3.12/site-packages/tangermeme/tools/tomtom.py (341)\n",
+      "\u001b[0m\n",
+      "\u001b[0m\u001b[1mDuring: resolving callee type: type(CPUDispatcher(<function _p_values at 0x709694269f80>))\u001b[0m\n",
+      "\u001b[0m\u001b[1mDuring: typing of call at /home/luna.kuleuven.be/u0166574/miniconda3/envs/crested_dev_torch/lib/python3.12/site-packages/tangermeme/tools/tomtom.py (341)\n",
+      "\u001b[0m\n",
+      "\u001b[1m\n",
+      "File \"../../../miniconda3/envs/crested_dev_torch/lib/python3.12/site-packages/tangermeme/tools/tomtom.py\", line 341:\u001b[0m\n",
+      "\u001b[1mdef _tomtom(Q, T, Q_lens, T_lens, Q_norm, T_norm, rr_inv, rr_counts, n_nearest, \n",
+      "    <source elided>\n",
+      "\n",
+      "\u001b[1m\t\t_p_values(_gamma[pid], _B[pid], rr_inv, T_lens, nq, offset, \n",
+      "\u001b[0m  \u001b[1m^\u001b[0m\u001b[0m\n",
+      "\n",
+      "Warning: TOMTOM error while comparing patterns Astro_pos_patterns_3 and Astro_pos_patterns_1. Returning no match.\n",
+      "Error details: Failed in nopython mode pipeline (step: nopython frontend)\n",
+      "\u001b[1m\u001b[1m\u001b[1m\u001b[1mFailed in nopython mode pipeline (step: nopython frontend)\n",
+      "\u001b[1m\u001b[1mNo implementation of function Function(<built-in function iadd>) found for signature:\n",
+      " \n",
+      " >>> iadd(Literal[int](0), array(int32, 1d, C))\n",
+      " \n",
+      "There are 18 candidate implementations:\n",
+      "\u001b[1m     - Of which 16 did not match due to:\n",
+      "     Overload of function 'iadd': File: <numerous>: Line N/A.\n",
+      "       With argument(s): '(int64, array(int32, 1d, C))':\u001b[0m\n",
+      "\u001b[1m      No match.\u001b[0m\n",
+      "\u001b[1m     - Of which 2 did not match due to:\n",
+      "     Operator Overload in function 'iadd': File: unknown: Line unknown.\n",
+      "       With argument(s): '(int64, array(int32, 1d, C))':\u001b[0m\n",
+      "\u001b[1m      No match for registered cases:\n",
+      "       * (int64, int64) -> int64\n",
+      "       * (int64, uint64) -> int64\n",
+      "       * (uint64, int64) -> int64\n",
+      "       * (uint64, uint64) -> uint64\n",
+      "       * (float32, float32) -> float32\n",
+      "       * (float64, float64) -> float64\n",
+      "       * (complex64, complex64) -> complex64\n",
+      "       * (complex128, complex128) -> complex128\u001b[0m\n",
+      "\u001b[0m\n",
+      "\u001b[0m\u001b[1mDuring: typing of intrinsic-call at /home/luna.kuleuven.be/u0166574/miniconda3/envs/crested_dev_torch/lib/python3.12/site-packages/tangermeme/tools/tomtom.py (242)\u001b[0m\n",
+      "\u001b[1m\n",
+      "File \"../../../miniconda3/envs/crested_dev_torch/lib/python3.12/site-packages/tangermeme/tools/tomtom.py\", line 242:\u001b[0m\n",
+      "\u001b[1mdef _p_values(gamma, B_cdfs, rr_inv, T_lens, nq, offset, n_bins, results):\n",
+      "    <source elided>\n",
+      "\t\t\t\t\tj, t_idx = uint64(j), uint64(total_offset + j + k)\n",
+      "\u001b[1m\t\t\t\t\tscore += gamma[j, rr_inv[t_idx]]\n",
+      "\u001b[0m     \u001b[1m^\u001b[0m\u001b[0m\n",
+      "\n",
+      "\u001b[0m\u001b[1mDuring: resolving callee type: type(CPUDispatcher(<function _p_values at 0x709694269f80>))\u001b[0m\n",
+      "\u001b[0m\u001b[1mDuring: typing of call at /home/luna.kuleuven.be/u0166574/miniconda3/envs/crested_dev_torch/lib/python3.12/site-packages/tangermeme/tools/tomtom.py (341)\n",
+      "\u001b[0m\n",
+      "\u001b[0m\u001b[1mDuring: resolving callee type: type(CPUDispatcher(<function _p_values at 0x709694269f80>))\u001b[0m\n",
+      "\u001b[0m\u001b[1mDuring: typing of call at /home/luna.kuleuven.be/u0166574/miniconda3/envs/crested_dev_torch/lib/python3.12/site-packages/tangermeme/tools/tomtom.py (341)\n",
+      "\u001b[0m\n",
+      "\u001b[1m\n",
+      "File \"../../../miniconda3/envs/crested_dev_torch/lib/python3.12/site-packages/tangermeme/tools/tomtom.py\", line 341:\u001b[0m\n",
+      "\u001b[1mdef _tomtom(Q, T, Q_lens, T_lens, Q_norm, T_norm, rr_inv, rr_counts, n_nearest, \n",
+      "    <source elided>\n",
+      "\n",
+      "\u001b[1m\t\t_p_values(_gamma[pid], _B[pid], rr_inv, T_lens, nq, offset, \n",
+      "\u001b[0m  \u001b[1m^\u001b[0m\u001b[0m\n",
+      "\n",
+      "Warning: TOMTOM error while comparing patterns Astro_pos_patterns_3 and Astro_pos_patterns_2. Returning no match.\n",
+      "Error details: Failed in nopython mode pipeline (step: nopython frontend)\n",
+      "\u001b[1m\u001b[1m\u001b[1m\u001b[1mFailed in nopython mode pipeline (step: nopython frontend)\n",
+      "\u001b[1m\u001b[1mNo implementation of function Function(<built-in function iadd>) found for signature:\n",
+      " \n",
+      " >>> iadd(Literal[int](0), array(int32, 1d, C))\n",
+      " \n",
+      "There are 18 candidate implementations:\n",
+      "\u001b[1m     - Of which 16 did not match due to:\n",
+      "     Overload of function 'iadd': File: <numerous>: Line N/A.\n",
+      "       With argument(s): '(int64, array(int32, 1d, C))':\u001b[0m\n",
+      "\u001b[1m      No match.\u001b[0m\n",
+      "\u001b[1m     - Of which 2 did not match due to:\n",
+      "     Operator Overload in function 'iadd': File: unknown: Line unknown.\n",
+      "       With argument(s): '(int64, array(int32, 1d, C))':\u001b[0m\n",
+      "\u001b[1m      No match for registered cases:\n",
+      "       * (int64, int64) -> int64\n",
+      "       * (int64, uint64) -> int64\n",
+      "       * (uint64, int64) -> int64\n",
+      "       * (uint64, uint64) -> uint64\n",
+      "       * (float32, float32) -> float32\n",
+      "       * (float64, float64) -> float64\n",
+      "       * (complex64, complex64) -> complex64\n",
+      "       * (complex128, complex128) -> complex128\u001b[0m\n",
+      "\u001b[0m\n",
+      "\u001b[0m\u001b[1mDuring: typing of intrinsic-call at /home/luna.kuleuven.be/u0166574/miniconda3/envs/crested_dev_torch/lib/python3.12/site-packages/tangermeme/tools/tomtom.py (242)\u001b[0m\n",
+      "\u001b[1m\n",
+      "File \"../../../miniconda3/envs/crested_dev_torch/lib/python3.12/site-packages/tangermeme/tools/tomtom.py\", line 242:\u001b[0m\n",
+      "\u001b[1mdef _p_values(gamma, B_cdfs, rr_inv, T_lens, nq, offset, n_bins, results):\n",
+      "    <source elided>\n",
+      "\t\t\t\t\tj, t_idx = uint64(j), uint64(total_offset + j + k)\n",
+      "\u001b[1m\t\t\t\t\tscore += gamma[j, rr_inv[t_idx]]\n",
+      "\u001b[0m     \u001b[1m^\u001b[0m\u001b[0m\n",
+      "\n",
+      "\u001b[0m\u001b[1mDuring: resolving callee type: type(CPUDispatcher(<function _p_values at 0x709694269f80>))\u001b[0m\n",
+      "\u001b[0m\u001b[1mDuring: typing of call at /home/luna.kuleuven.be/u0166574/miniconda3/envs/crested_dev_torch/lib/python3.12/site-packages/tangermeme/tools/tomtom.py (341)\n",
+      "\u001b[0m\n",
+      "\u001b[0m\u001b[1mDuring: resolving callee type: type(CPUDispatcher(<function _p_values at 0x709694269f80>))\u001b[0m\n",
+      "\u001b[0m\u001b[1mDuring: typing of call at /home/luna.kuleuven.be/u0166574/miniconda3/envs/crested_dev_torch/lib/python3.12/site-packages/tangermeme/tools/tomtom.py (341)\n",
+      "\u001b[0m\n",
+      "\u001b[1m\n",
+      "File \"../../../miniconda3/envs/crested_dev_torch/lib/python3.12/site-packages/tangermeme/tools/tomtom.py\", line 341:\u001b[0m\n",
+      "\u001b[1mdef _tomtom(Q, T, Q_lens, T_lens, Q_norm, T_norm, rr_inv, rr_counts, n_nearest, \n",
+      "    <source elided>\n",
+      "\n",
+      "\u001b[1m\t\t_p_values(_gamma[pid], _B[pid], rr_inv, T_lens, nq, offset, \n",
+      "\u001b[0m  \u001b[1m^\u001b[0m\u001b[0m\n",
+      "\n",
+      "Warning: TOMTOM error while comparing patterns Astro_pos_patterns_0 and Astro_pos_patterns_1. Returning no match.\n",
+      "Error details: Failed in nopython mode pipeline (step: nopython frontend)\n",
+      "\u001b[1m\u001b[1m\u001b[1m\u001b[1mFailed in nopython mode pipeline (step: nopython frontend)\n",
+      "\u001b[1m\u001b[1mNo implementation of function Function(<built-in function iadd>) found for signature:\n",
+      " \n",
+      " >>> iadd(Literal[int](0), array(int32, 1d, C))\n",
+      " \n",
+      "There are 18 candidate implementations:\n",
+      "\u001b[1m     - Of which 16 did not match due to:\n",
+      "     Overload of function 'iadd': File: <numerous>: Line N/A.\n",
+      "       With argument(s): '(int64, array(int32, 1d, C))':\u001b[0m\n",
+      "\u001b[1m      No match.\u001b[0m\n",
+      "\u001b[1m     - Of which 2 did not match due to:\n",
+      "     Operator Overload in function 'iadd': File: unknown: Line unknown.\n",
+      "       With argument(s): '(int64, array(int32, 1d, C))':\u001b[0m\n",
+      "\u001b[1m      No match for registered cases:\n",
+      "       * (int64, int64) -> int64\n",
+      "       * (int64, uint64) -> int64\n",
+      "       * (uint64, int64) -> int64\n",
+      "       * (uint64, uint64) -> uint64\n",
+      "       * (float32, float32) -> float32\n",
+      "       * (float64, float64) -> float64\n",
+      "       * (complex64, complex64) -> complex64\n",
+      "       * (complex128, complex128) -> complex128\u001b[0m\n",
+      "\u001b[0m\n",
+      "\u001b[0m\u001b[1mDuring: typing of intrinsic-call at /home/luna.kuleuven.be/u0166574/miniconda3/envs/crested_dev_torch/lib/python3.12/site-packages/tangermeme/tools/tomtom.py (242)\u001b[0m\n",
+      "\u001b[1m\n",
+      "File \"../../../miniconda3/envs/crested_dev_torch/lib/python3.12/site-packages/tangermeme/tools/tomtom.py\", line 242:\u001b[0m\n",
+      "\u001b[1mdef _p_values(gamma, B_cdfs, rr_inv, T_lens, nq, offset, n_bins, results):\n",
+      "    <source elided>\n",
+      "\t\t\t\t\tj, t_idx = uint64(j), uint64(total_offset + j + k)\n",
+      "\u001b[1m\t\t\t\t\tscore += gamma[j, rr_inv[t_idx]]\n",
+      "\u001b[0m     \u001b[1m^\u001b[0m\u001b[0m\n",
+      "\n",
+      "\u001b[0m\u001b[1mDuring: resolving callee type: type(CPUDispatcher(<function _p_values at 0x709694269f80>))\u001b[0m\n",
+      "\u001b[0m\u001b[1mDuring: typing of call at /home/luna.kuleuven.be/u0166574/miniconda3/envs/crested_dev_torch/lib/python3.12/site-packages/tangermeme/tools/tomtom.py (341)\n",
+      "\u001b[0m\n",
+      "\u001b[0m\u001b[1mDuring: resolving callee type: type(CPUDispatcher(<function _p_values at 0x709694269f80>))\u001b[0m\n",
+      "\u001b[0m\u001b[1mDuring: typing of call at /home/luna.kuleuven.be/u0166574/miniconda3/envs/crested_dev_torch/lib/python3.12/site-packages/tangermeme/tools/tomtom.py (341)\n",
+      "\u001b[0m\n",
+      "\u001b[1m\n",
+      "File \"../../../miniconda3/envs/crested_dev_torch/lib/python3.12/site-packages/tangermeme/tools/tomtom.py\", line 341:\u001b[0m\n",
+      "\u001b[1mdef _tomtom(Q, T, Q_lens, T_lens, Q_norm, T_norm, rr_inv, rr_counts, n_nearest, \n",
+      "    <source elided>\n",
+      "\n",
+      "\u001b[1m\t\t_p_values(_gamma[pid], _B[pid], rr_inv, T_lens, nq, offset, \n",
+      "\u001b[0m  \u001b[1m^\u001b[0m\u001b[0m\n",
+      "\n",
+      "Warning: TOMTOM error while comparing patterns Astro_pos_patterns_1 and Astro_pos_patterns_0. Returning no match.\n",
+      "Error details: Failed in nopython mode pipeline (step: nopython frontend)\n",
+      "\u001b[1m\u001b[1m\u001b[1m\u001b[1mFailed in nopython mode pipeline (step: nopython frontend)\n",
+      "\u001b[1m\u001b[1mNo implementation of function Function(<built-in function iadd>) found for signature:\n",
+      " \n",
+      " >>> iadd(Literal[int](0), array(int32, 1d, C))\n",
+      " \n",
+      "There are 18 candidate implementations:\n",
+      "\u001b[1m     - Of which 16 did not match due to:\n",
+      "     Overload of function 'iadd': File: <numerous>: Line N/A.\n",
+      "       With argument(s): '(int64, array(int32, 1d, C))':\u001b[0m\n",
+      "\u001b[1m      No match.\u001b[0m\n",
+      "\u001b[1m     - Of which 2 did not match due to:\n",
+      "     Operator Overload in function 'iadd': File: unknown: Line unknown.\n",
+      "       With argument(s): '(int64, array(int32, 1d, C))':\u001b[0m\n",
+      "\u001b[1m      No match for registered cases:\n",
+      "       * (int64, int64) -> int64\n",
+      "       * (int64, uint64) -> int64\n",
+      "       * (uint64, int64) -> int64\n",
+      "       * (uint64, uint64) -> uint64\n",
+      "       * (float32, float32) -> float32\n",
+      "       * (float64, float64) -> float64\n",
+      "       * (complex64, complex64) -> complex64\n",
+      "       * (complex128, complex128) -> complex128\u001b[0m\n",
+      "\u001b[0m\n",
+      "\u001b[0m\u001b[1mDuring: typing of intrinsic-call at /home/luna.kuleuven.be/u0166574/miniconda3/envs/crested_dev_torch/lib/python3.12/site-packages/tangermeme/tools/tomtom.py (242)\u001b[0m\n",
+      "\u001b[1m\n",
+      "File \"../../../miniconda3/envs/crested_dev_torch/lib/python3.12/site-packages/tangermeme/tools/tomtom.py\", line 242:\u001b[0m\n",
+      "\u001b[1mdef _p_values(gamma, B_cdfs, rr_inv, T_lens, nq, offset, n_bins, results):\n",
+      "    <source elided>\n",
+      "\t\t\t\t\tj, t_idx = uint64(j), uint64(total_offset + j + k)\n",
+      "\u001b[1m\t\t\t\t\tscore += gamma[j, rr_inv[t_idx]]\n",
+      "\u001b[0m     \u001b[1m^\u001b[0m\u001b[0m\n",
+      "\n",
+      "\u001b[0m\u001b[1mDuring: resolving callee type: type(CPUDispatcher(<function _p_values at 0x709694269f80>))\u001b[0m\n",
+      "\u001b[0m\u001b[1mDuring: typing of call at /home/luna.kuleuven.be/u0166574/miniconda3/envs/crested_dev_torch/lib/python3.12/site-packages/tangermeme/tools/tomtom.py (341)\n",
+      "\u001b[0m\n",
+      "\u001b[0m\u001b[1mDuring: resolving callee type: type(CPUDispatcher(<function _p_values at 0x709694269f80>))\u001b[0m\n",
+      "\u001b[0m\u001b[1mDuring: typing of call at /home/luna.kuleuven.be/u0166574/miniconda3/envs/crested_dev_torch/lib/python3.12/site-packages/tangermeme/tools/tomtom.py (341)\n",
+      "\u001b[0m\n",
+      "\u001b[1m\n",
+      "File \"../../../miniconda3/envs/crested_dev_torch/lib/python3.12/site-packages/tangermeme/tools/tomtom.py\", line 341:\u001b[0m\n",
+      "\u001b[1mdef _tomtom(Q, T, Q_lens, T_lens, Q_norm, T_norm, rr_inv, rr_counts, n_nearest, \n",
+      "    <source elided>\n",
+      "\n",
+      "\u001b[1m\t\t_p_values(_gamma[pid], _B[pid], rr_inv, T_lens, nq, offset, \n",
+      "\u001b[0m  \u001b[1m^\u001b[0m\u001b[0m\n",
+      "\n",
+      "Warning: TOMTOM error while comparing patterns Astro_pos_patterns_0 and Astro_pos_patterns_2. Returning no match.\n",
+      "Error details: Failed in nopython mode pipeline (step: nopython frontend)\n",
+      "\u001b[1m\u001b[1m\u001b[1m\u001b[1mFailed in nopython mode pipeline (step: nopython frontend)\n",
+      "\u001b[1m\u001b[1mNo implementation of function Function(<built-in function iadd>) found for signature:\n",
+      " \n",
+      " >>> iadd(Literal[int](0), array(int32, 1d, C))\n",
+      " \n",
+      "There are 18 candidate implementations:\n",
+      "\u001b[1m     - Of which 16 did not match due to:\n",
+      "     Overload of function 'iadd': File: <numerous>: Line N/A.\n",
+      "       With argument(s): '(int64, array(int32, 1d, C))':\u001b[0m\n",
+      "\u001b[1m      No match.\u001b[0m\n",
+      "\u001b[1m     - Of which 2 did not match due to:\n",
+      "     Operator Overload in function 'iadd': File: unknown: Line unknown.\n",
+      "       With argument(s): '(int64, array(int32, 1d, C))':\u001b[0m\n",
+      "\u001b[1m      No match for registered cases:\n",
+      "       * (int64, int64) -> int64\n",
+      "       * (int64, uint64) -> int64\n",
+      "       * (uint64, int64) -> int64\n",
+      "       * (uint64, uint64) -> uint64\n",
+      "       * (float32, float32) -> float32\n",
+      "       * (float64, float64) -> float64\n",
+      "       * (complex64, complex64) -> complex64\n",
+      "       * (complex128, complex128) -> complex128\u001b[0m\n",
+      "\u001b[0m\n",
+      "\u001b[0m\u001b[1mDuring: typing of intrinsic-call at /home/luna.kuleuven.be/u0166574/miniconda3/envs/crested_dev_torch/lib/python3.12/site-packages/tangermeme/tools/tomtom.py (242)\u001b[0m\n",
+      "\u001b[1m\n",
+      "File \"../../../miniconda3/envs/crested_dev_torch/lib/python3.12/site-packages/tangermeme/tools/tomtom.py\", line 242:\u001b[0m\n",
+      "\u001b[1mdef _p_values(gamma, B_cdfs, rr_inv, T_lens, nq, offset, n_bins, results):\n",
+      "    <source elided>\n",
+      "\t\t\t\t\tj, t_idx = uint64(j), uint64(total_offset + j + k)\n",
+      "\u001b[1m\t\t\t\t\tscore += gamma[j, rr_inv[t_idx]]\n",
+      "\u001b[0m     \u001b[1m^\u001b[0m\u001b[0m\n",
+      "\n",
+      "\u001b[0m\u001b[1mDuring: resolving callee type: type(CPUDispatcher(<function _p_values at 0x709694269f80>))\u001b[0m\n",
+      "\u001b[0m\u001b[1mDuring: typing of call at /home/luna.kuleuven.be/u0166574/miniconda3/envs/crested_dev_torch/lib/python3.12/site-packages/tangermeme/tools/tomtom.py (341)\n",
+      "\u001b[0m\n",
+      "\u001b[0m\u001b[1mDuring: resolving callee type: type(CPUDispatcher(<function _p_values at 0x709694269f80>))\u001b[0m\n",
+      "\u001b[0m\u001b[1mDuring: typing of call at /home/luna.kuleuven.be/u0166574/miniconda3/envs/crested_dev_torch/lib/python3.12/site-packages/tangermeme/tools/tomtom.py (341)\n",
+      "\u001b[0m\n",
+      "\u001b[1m\n",
+      "File \"../../../miniconda3/envs/crested_dev_torch/lib/python3.12/site-packages/tangermeme/tools/tomtom.py\", line 341:\u001b[0m\n",
+      "\u001b[1mdef _tomtom(Q, T, Q_lens, T_lens, Q_norm, T_norm, rr_inv, rr_counts, n_nearest, \n",
+      "    <source elided>\n",
+      "\n",
+      "\u001b[1m\t\t_p_values(_gamma[pid], _B[pid], rr_inv, T_lens, nq, offset, \n",
+      "\u001b[0m  \u001b[1m^\u001b[0m\u001b[0m\n",
+      "\n",
+      "Warning: TOMTOM error while comparing patterns Astro_pos_patterns_2 and Astro_pos_patterns_0. Returning no match.\n",
+      "Error details: Failed in nopython mode pipeline (step: nopython frontend)\n",
+      "\u001b[1m\u001b[1m\u001b[1m\u001b[1mFailed in nopython mode pipeline (step: nopython frontend)\n",
+      "\u001b[1m\u001b[1mNo implementation of function Function(<built-in function iadd>) found for signature:\n",
+      " \n",
+      " >>> iadd(Literal[int](0), array(int32, 1d, C))\n",
+      " \n",
+      "There are 18 candidate implementations:\n",
+      "\u001b[1m     - Of which 16 did not match due to:\n",
+      "     Overload of function 'iadd': File: <numerous>: Line N/A.\n",
+      "       With argument(s): '(int64, array(int32, 1d, C))':\u001b[0m\n",
+      "\u001b[1m      No match.\u001b[0m\n",
+      "\u001b[1m     - Of which 2 did not match due to:\n",
+      "     Operator Overload in function 'iadd': File: unknown: Line unknown.\n",
+      "       With argument(s): '(int64, array(int32, 1d, C))':\u001b[0m\n",
+      "\u001b[1m      No match for registered cases:\n",
+      "       * (int64, int64) -> int64\n",
+      "       * (int64, uint64) -> int64\n",
+      "       * (uint64, int64) -> int64\n",
+      "       * (uint64, uint64) -> uint64\n",
+      "       * (float32, float32) -> float32\n",
+      "       * (float64, float64) -> float64\n",
+      "       * (complex64, complex64) -> complex64\n",
+      "       * (complex128, complex128) -> complex128\u001b[0m\n",
+      "\u001b[0m\n",
+      "\u001b[0m\u001b[1mDuring: typing of intrinsic-call at /home/luna.kuleuven.be/u0166574/miniconda3/envs/crested_dev_torch/lib/python3.12/site-packages/tangermeme/tools/tomtom.py (242)\u001b[0m\n",
+      "\u001b[1m\n",
+      "File \"../../../miniconda3/envs/crested_dev_torch/lib/python3.12/site-packages/tangermeme/tools/tomtom.py\", line 242:\u001b[0m\n",
+      "\u001b[1mdef _p_values(gamma, B_cdfs, rr_inv, T_lens, nq, offset, n_bins, results):\n",
+      "    <source elided>\n",
+      "\t\t\t\t\tj, t_idx = uint64(j), uint64(total_offset + j + k)\n",
+      "\u001b[1m\t\t\t\t\tscore += gamma[j, rr_inv[t_idx]]\n",
+      "\u001b[0m     \u001b[1m^\u001b[0m\u001b[0m\n",
+      "\n",
+      "\u001b[0m\u001b[1mDuring: resolving callee type: type(CPUDispatcher(<function _p_values at 0x709694269f80>))\u001b[0m\n",
+      "\u001b[0m\u001b[1mDuring: typing of call at /home/luna.kuleuven.be/u0166574/miniconda3/envs/crested_dev_torch/lib/python3.12/site-packages/tangermeme/tools/tomtom.py (341)\n",
+      "\u001b[0m\n",
+      "\u001b[0m\u001b[1mDuring: resolving callee type: type(CPUDispatcher(<function _p_values at 0x709694269f80>))\u001b[0m\n",
+      "\u001b[0m\u001b[1mDuring: typing of call at /home/luna.kuleuven.be/u0166574/miniconda3/envs/crested_dev_torch/lib/python3.12/site-packages/tangermeme/tools/tomtom.py (341)\n",
+      "\u001b[0m\n",
+      "\u001b[1m\n",
+      "File \"../../../miniconda3/envs/crested_dev_torch/lib/python3.12/site-packages/tangermeme/tools/tomtom.py\", line 341:\u001b[0m\n",
+      "\u001b[1mdef _tomtom(Q, T, Q_lens, T_lens, Q_norm, T_norm, rr_inv, rr_counts, n_nearest, \n",
+      "    <source elided>\n",
+      "\n",
+      "\u001b[1m\t\t_p_values(_gamma[pid], _B[pid], rr_inv, T_lens, nq, offset, \n",
+      "\u001b[0m  \u001b[1m^\u001b[0m\u001b[0m\n",
+      "\n",
+      "Warning: TOMTOM error while comparing patterns Astro_pos_patterns_0 and Astro_pos_patterns_3. Returning no match.\n",
+      "Error details: Failed in nopython mode pipeline (step: nopython frontend)\n",
+      "\u001b[1m\u001b[1m\u001b[1m\u001b[1mFailed in nopython mode pipeline (step: nopython frontend)\n",
+      "\u001b[1m\u001b[1mNo implementation of function Function(<built-in function iadd>) found for signature:\n",
+      " \n",
+      " >>> iadd(Literal[int](0), array(int32, 1d, C))\n",
+      " \n",
+      "There are 18 candidate implementations:\n",
+      "\u001b[1m     - Of which 16 did not match due to:\n",
+      "     Overload of function 'iadd': File: <numerous>: Line N/A.\n",
+      "       With argument(s): '(int64, array(int32, 1d, C))':\u001b[0m\n",
+      "\u001b[1m      No match.\u001b[0m\n",
+      "\u001b[1m     - Of which 2 did not match due to:\n",
+      "     Operator Overload in function 'iadd': File: unknown: Line unknown.\n",
+      "       With argument(s): '(int64, array(int32, 1d, C))':\u001b[0m\n",
+      "\u001b[1m      No match for registered cases:\n",
+      "       * (int64, int64) -> int64\n",
+      "       * (int64, uint64) -> int64\n",
+      "       * (uint64, int64) -> int64\n",
+      "       * (uint64, uint64) -> uint64\n",
+      "       * (float32, float32) -> float32\n",
+      "       * (float64, float64) -> float64\n",
+      "       * (complex64, complex64) -> complex64\n",
+      "       * (complex128, complex128) -> complex128\u001b[0m\n",
+      "\u001b[0m\n",
+      "\u001b[0m\u001b[1mDuring: typing of intrinsic-call at /home/luna.kuleuven.be/u0166574/miniconda3/envs/crested_dev_torch/lib/python3.12/site-packages/tangermeme/tools/tomtom.py (242)\u001b[0m\n",
+      "\u001b[1m\n",
+      "File \"../../../miniconda3/envs/crested_dev_torch/lib/python3.12/site-packages/tangermeme/tools/tomtom.py\", line 242:\u001b[0m\n",
+      "\u001b[1mdef _p_values(gamma, B_cdfs, rr_inv, T_lens, nq, offset, n_bins, results):\n",
+      "    <source elided>\n",
+      "\t\t\t\t\tj, t_idx = uint64(j), uint64(total_offset + j + k)\n",
+      "\u001b[1m\t\t\t\t\tscore += gamma[j, rr_inv[t_idx]]\n",
+      "\u001b[0m     \u001b[1m^\u001b[0m\u001b[0m\n",
+      "\n",
+      "\u001b[0m\u001b[1mDuring: resolving callee type: type(CPUDispatcher(<function _p_values at 0x709694269f80>))\u001b[0m\n",
+      "\u001b[0m\u001b[1mDuring: typing of call at /home/luna.kuleuven.be/u0166574/miniconda3/envs/crested_dev_torch/lib/python3.12/site-packages/tangermeme/tools/tomtom.py (341)\n",
+      "\u001b[0m\n",
+      "\u001b[0m\u001b[1mDuring: resolving callee type: type(CPUDispatcher(<function _p_values at 0x709694269f80>))\u001b[0m\n",
+      "\u001b[0m\u001b[1mDuring: typing of call at /home/luna.kuleuven.be/u0166574/miniconda3/envs/crested_dev_torch/lib/python3.12/site-packages/tangermeme/tools/tomtom.py (341)\n",
+      "\u001b[0m\n",
+      "\u001b[1m\n",
+      "File \"../../../miniconda3/envs/crested_dev_torch/lib/python3.12/site-packages/tangermeme/tools/tomtom.py\", line 341:\u001b[0m\n",
+      "\u001b[1mdef _tomtom(Q, T, Q_lens, T_lens, Q_norm, T_norm, rr_inv, rr_counts, n_nearest, \n",
+      "    <source elided>\n",
+      "\n",
+      "\u001b[1m\t\t_p_values(_gamma[pid], _B[pid], rr_inv, T_lens, nq, offset, \n",
+      "\u001b[0m  \u001b[1m^\u001b[0m\u001b[0m\n",
+      "\n",
+      "Warning: TOMTOM error while comparing patterns Astro_pos_patterns_3 and Astro_pos_patterns_0. Returning no match.\n",
+      "Error details: Failed in nopython mode pipeline (step: nopython frontend)\n",
+      "\u001b[1m\u001b[1m\u001b[1m\u001b[1mFailed in nopython mode pipeline (step: nopython frontend)\n",
+      "\u001b[1m\u001b[1mNo implementation of function Function(<built-in function iadd>) found for signature:\n",
+      " \n",
+      " >>> iadd(Literal[int](0), array(int32, 1d, C))\n",
+      " \n",
+      "There are 18 candidate implementations:\n",
+      "\u001b[1m     - Of which 16 did not match due to:\n",
+      "     Overload of function 'iadd': File: <numerous>: Line N/A.\n",
+      "       With argument(s): '(int64, array(int32, 1d, C))':\u001b[0m\n",
+      "\u001b[1m      No match.\u001b[0m\n",
+      "\u001b[1m     - Of which 2 did not match due to:\n",
+      "     Operator Overload in function 'iadd': File: unknown: Line unknown.\n",
+      "       With argument(s): '(int64, array(int32, 1d, C))':\u001b[0m\n",
+      "\u001b[1m      No match for registered cases:\n",
+      "       * (int64, int64) -> int64\n",
+      "       * (int64, uint64) -> int64\n",
+      "       * (uint64, int64) -> int64\n",
+      "       * (uint64, uint64) -> uint64\n",
+      "       * (float32, float32) -> float32\n",
+      "       * (float64, float64) -> float64\n",
+      "       * (complex64, complex64) -> complex64\n",
+      "       * (complex128, complex128) -> complex128\u001b[0m\n",
+      "\u001b[0m\n",
+      "\u001b[0m\u001b[1mDuring: typing of intrinsic-call at /home/luna.kuleuven.be/u0166574/miniconda3/envs/crested_dev_torch/lib/python3.12/site-packages/tangermeme/tools/tomtom.py (242)\u001b[0m\n",
+      "\u001b[1m\n",
+      "File \"../../../miniconda3/envs/crested_dev_torch/lib/python3.12/site-packages/tangermeme/tools/tomtom.py\", line 242:\u001b[0m\n",
+      "\u001b[1mdef _p_values(gamma, B_cdfs, rr_inv, T_lens, nq, offset, n_bins, results):\n",
+      "    <source elided>\n",
+      "\t\t\t\t\tj, t_idx = uint64(j), uint64(total_offset + j + k)\n",
+      "\u001b[1m\t\t\t\t\tscore += gamma[j, rr_inv[t_idx]]\n",
+      "\u001b[0m     \u001b[1m^\u001b[0m\u001b[0m\n",
+      "\n",
+      "\u001b[0m\u001b[1mDuring: resolving callee type: type(CPUDispatcher(<function _p_values at 0x709694269f80>))\u001b[0m\n",
+      "\u001b[0m\u001b[1mDuring: typing of call at /home/luna.kuleuven.be/u0166574/miniconda3/envs/crested_dev_torch/lib/python3.12/site-packages/tangermeme/tools/tomtom.py (341)\n",
+      "\u001b[0m\n",
+      "\u001b[0m\u001b[1mDuring: resolving callee type: type(CPUDispatcher(<function _p_values at 0x709694269f80>))\u001b[0m\n",
+      "\u001b[0m\u001b[1mDuring: typing of call at /home/luna.kuleuven.be/u0166574/miniconda3/envs/crested_dev_torch/lib/python3.12/site-packages/tangermeme/tools/tomtom.py (341)\n",
+      "\u001b[0m\n",
+      "\u001b[1m\n",
+      "File \"../../../miniconda3/envs/crested_dev_torch/lib/python3.12/site-packages/tangermeme/tools/tomtom.py\", line 341:\u001b[0m\n",
+      "\u001b[1mdef _tomtom(Q, T, Q_lens, T_lens, Q_norm, T_norm, rr_inv, rr_counts, n_nearest, \n",
+      "    <source elided>\n",
+      "\n",
+      "\u001b[1m\t\t_p_values(_gamma[pid], _B[pid], rr_inv, T_lens, nq, offset, \n",
+      "\u001b[0m  \u001b[1m^\u001b[0m\u001b[0m\n",
+      "\n",
+      "Warning: TOMTOM error while comparing patterns Astro_pos_patterns_1 and Astro_pos_patterns_2. Returning no match.\n",
+      "Error details: Failed in nopython mode pipeline (step: nopython frontend)\n",
+      "\u001b[1m\u001b[1m\u001b[1m\u001b[1mFailed in nopython mode pipeline (step: nopython frontend)\n",
+      "\u001b[1m\u001b[1mNo implementation of function Function(<built-in function iadd>) found for signature:\n",
+      " \n",
+      " >>> iadd(Literal[int](0), array(int32, 1d, C))\n",
+      " \n",
+      "There are 18 candidate implementations:\n",
+      "\u001b[1m     - Of which 16 did not match due to:\n",
+      "     Overload of function 'iadd': File: <numerous>: Line N/A.\n",
+      "       With argument(s): '(int64, array(int32, 1d, C))':\u001b[0m\n",
+      "\u001b[1m      No match.\u001b[0m\n",
+      "\u001b[1m     - Of which 2 did not match due to:\n",
+      "     Operator Overload in function 'iadd': File: unknown: Line unknown.\n",
+      "       With argument(s): '(int64, array(int32, 1d, C))':\u001b[0m\n",
+      "\u001b[1m      No match for registered cases:\n",
+      "       * (int64, int64) -> int64\n",
+      "       * (int64, uint64) -> int64\n",
+      "       * (uint64, int64) -> int64\n",
+      "       * (uint64, uint64) -> uint64\n",
+      "       * (float32, float32) -> float32\n",
+      "       * (float64, float64) -> float64\n",
+      "       * (complex64, complex64) -> complex64\n",
+      "       * (complex128, complex128) -> complex128\u001b[0m\n",
+      "\u001b[0m\n",
+      "\u001b[0m\u001b[1mDuring: typing of intrinsic-call at /home/luna.kuleuven.be/u0166574/miniconda3/envs/crested_dev_torch/lib/python3.12/site-packages/tangermeme/tools/tomtom.py (242)\u001b[0m\n",
+      "\u001b[1m\n",
+      "File \"../../../miniconda3/envs/crested_dev_torch/lib/python3.12/site-packages/tangermeme/tools/tomtom.py\", line 242:\u001b[0m\n",
+      "\u001b[1mdef _p_values(gamma, B_cdfs, rr_inv, T_lens, nq, offset, n_bins, results):\n",
+      "    <source elided>\n",
+      "\t\t\t\t\tj, t_idx = uint64(j), uint64(total_offset + j + k)\n",
+      "\u001b[1m\t\t\t\t\tscore += gamma[j, rr_inv[t_idx]]\n",
+      "\u001b[0m     \u001b[1m^\u001b[0m\u001b[0m\n",
+      "\n",
+      "\u001b[0m\u001b[1mDuring: resolving callee type: type(CPUDispatcher(<function _p_values at 0x709694269f80>))\u001b[0m\n",
+      "\u001b[0m\u001b[1mDuring: typing of call at /home/luna.kuleuven.be/u0166574/miniconda3/envs/crested_dev_torch/lib/python3.12/site-packages/tangermeme/tools/tomtom.py (341)\n",
+      "\u001b[0m\n",
+      "\u001b[0m\u001b[1mDuring: resolving callee type: type(CPUDispatcher(<function _p_values at 0x709694269f80>))\u001b[0m\n",
+      "\u001b[0m\u001b[1mDuring: typing of call at /home/luna.kuleuven.be/u0166574/miniconda3/envs/crested_dev_torch/lib/python3.12/site-packages/tangermeme/tools/tomtom.py (341)\n",
+      "\u001b[0m\n",
+      "\u001b[1m\n",
+      "File \"../../../miniconda3/envs/crested_dev_torch/lib/python3.12/site-packages/tangermeme/tools/tomtom.py\", line 341:\u001b[0m\n",
+      "\u001b[1mdef _tomtom(Q, T, Q_lens, T_lens, Q_norm, T_norm, rr_inv, rr_counts, n_nearest, \n",
+      "    <source elided>\n",
+      "\n",
+      "\u001b[1m\t\t_p_values(_gamma[pid], _B[pid], rr_inv, T_lens, nq, offset, \n",
+      "\u001b[0m  \u001b[1m^\u001b[0m\u001b[0m\n",
+      "\n",
+      "Warning: TOMTOM error while comparing patterns Astro_pos_patterns_2 and Astro_pos_patterns_1. Returning no match.\n",
+      "Error details: Failed in nopython mode pipeline (step: nopython frontend)\n",
+      "\u001b[1m\u001b[1m\u001b[1m\u001b[1mFailed in nopython mode pipeline (step: nopython frontend)\n",
+      "\u001b[1m\u001b[1mNo implementation of function Function(<built-in function iadd>) found for signature:\n",
+      " \n",
+      " >>> iadd(Literal[int](0), array(int32, 1d, C))\n",
+      " \n",
+      "There are 18 candidate implementations:\n",
+      "\u001b[1m     - Of which 16 did not match due to:\n",
+      "     Overload of function 'iadd': File: <numerous>: Line N/A.\n",
+      "       With argument(s): '(int64, array(int32, 1d, C))':\u001b[0m\n",
+      "\u001b[1m      No match.\u001b[0m\n",
+      "\u001b[1m     - Of which 2 did not match due to:\n",
+      "     Operator Overload in function 'iadd': File: unknown: Line unknown.\n",
+      "       With argument(s): '(int64, array(int32, 1d, C))':\u001b[0m\n",
+      "\u001b[1m      No match for registered cases:\n",
+      "       * (int64, int64) -> int64\n",
+      "       * (int64, uint64) -> int64\n",
+      "       * (uint64, int64) -> int64\n",
+      "       * (uint64, uint64) -> uint64\n",
+      "       * (float32, float32) -> float32\n",
+      "       * (float64, float64) -> float64\n",
+      "       * (complex64, complex64) -> complex64\n",
+      "       * (complex128, complex128) -> complex128\u001b[0m\n",
+      "\u001b[0m\n",
+      "\u001b[0m\u001b[1mDuring: typing of intrinsic-call at /home/luna.kuleuven.be/u0166574/miniconda3/envs/crested_dev_torch/lib/python3.12/site-packages/tangermeme/tools/tomtom.py (242)\u001b[0m\n",
+      "\u001b[1m\n",
+      "File \"../../../miniconda3/envs/crested_dev_torch/lib/python3.12/site-packages/tangermeme/tools/tomtom.py\", line 242:\u001b[0m\n",
+      "\u001b[1mdef _p_values(gamma, B_cdfs, rr_inv, T_lens, nq, offset, n_bins, results):\n",
+      "    <source elided>\n",
+      "\t\t\t\t\tj, t_idx = uint64(j), uint64(total_offset + j + k)\n",
+      "\u001b[1m\t\t\t\t\tscore += gamma[j, rr_inv[t_idx]]\n",
+      "\u001b[0m     \u001b[1m^\u001b[0m\u001b[0m\n",
+      "\n",
+      "\u001b[0m\u001b[1mDuring: resolving callee type: type(CPUDispatcher(<function _p_values at 0x709694269f80>))\u001b[0m\n",
+      "\u001b[0m\u001b[1mDuring: typing of call at /home/luna.kuleuven.be/u0166574/miniconda3/envs/crested_dev_torch/lib/python3.12/site-packages/tangermeme/tools/tomtom.py (341)\n",
+      "\u001b[0m\n",
+      "\u001b[0m\u001b[1mDuring: resolving callee type: type(CPUDispatcher(<function _p_values at 0x709694269f80>))\u001b[0m\n",
+      "\u001b[0m\u001b[1mDuring: typing of call at /home/luna.kuleuven.be/u0166574/miniconda3/envs/crested_dev_torch/lib/python3.12/site-packages/tangermeme/tools/tomtom.py (341)\n",
+      "\u001b[0m\n",
+      "\u001b[1m\n",
+      "File \"../../../miniconda3/envs/crested_dev_torch/lib/python3.12/site-packages/tangermeme/tools/tomtom.py\", line 341:\u001b[0m\n",
+      "\u001b[1mdef _tomtom(Q, T, Q_lens, T_lens, Q_norm, T_norm, rr_inv, rr_counts, n_nearest, \n",
+      "    <source elided>\n",
+      "\n",
+      "\u001b[1m\t\t_p_values(_gamma[pid], _B[pid], rr_inv, T_lens, nq, offset, \n",
+      "\u001b[0m  \u001b[1m^\u001b[0m\u001b[0m\n",
+      "\n",
+      "Warning: TOMTOM error while comparing patterns Astro_pos_patterns_1 and Astro_pos_patterns_3. Returning no match.\n",
+      "Error details: Failed in nopython mode pipeline (step: nopython frontend)\n",
+      "\u001b[1m\u001b[1m\u001b[1m\u001b[1mFailed in nopython mode pipeline (step: nopython frontend)\n",
+      "\u001b[1m\u001b[1mNo implementation of function Function(<built-in function iadd>) found for signature:\n",
+      " \n",
+      " >>> iadd(Literal[int](0), array(int32, 1d, C))\n",
+      " \n",
+      "There are 18 candidate implementations:\n",
+      "\u001b[1m     - Of which 16 did not match due to:\n",
+      "     Overload of function 'iadd': File: <numerous>: Line N/A.\n",
+      "       With argument(s): '(int64, array(int32, 1d, C))':\u001b[0m\n",
+      "\u001b[1m      No match.\u001b[0m\n",
+      "\u001b[1m     - Of which 2 did not match due to:\n",
+      "     Operator Overload in function 'iadd': File: unknown: Line unknown.\n",
+      "       With argument(s): '(int64, array(int32, 1d, C))':\u001b[0m\n",
+      "\u001b[1m      No match for registered cases:\n",
+      "       * (int64, int64) -> int64\n",
+      "       * (int64, uint64) -> int64\n",
+      "       * (uint64, int64) -> int64\n",
+      "       * (uint64, uint64) -> uint64\n",
+      "       * (float32, float32) -> float32\n",
+      "       * (float64, float64) -> float64\n",
+      "       * (complex64, complex64) -> complex64\n",
+      "       * (complex128, complex128) -> complex128\u001b[0m\n",
+      "\u001b[0m\n",
+      "\u001b[0m\u001b[1mDuring: typing of intrinsic-call at /home/luna.kuleuven.be/u0166574/miniconda3/envs/crested_dev_torch/lib/python3.12/site-packages/tangermeme/tools/tomtom.py (242)\u001b[0m\n",
+      "\u001b[1m\n",
+      "File \"../../../miniconda3/envs/crested_dev_torch/lib/python3.12/site-packages/tangermeme/tools/tomtom.py\", line 242:\u001b[0m\n",
+      "\u001b[1mdef _p_values(gamma, B_cdfs, rr_inv, T_lens, nq, offset, n_bins, results):\n",
+      "    <source elided>\n",
+      "\t\t\t\t\tj, t_idx = uint64(j), uint64(total_offset + j + k)\n",
+      "\u001b[1m\t\t\t\t\tscore += gamma[j, rr_inv[t_idx]]\n",
+      "\u001b[0m     \u001b[1m^\u001b[0m\u001b[0m\n",
+      "\n",
+      "\u001b[0m\u001b[1mDuring: resolving callee type: type(CPUDispatcher(<function _p_values at 0x709694269f80>))\u001b[0m\n",
+      "\u001b[0m\u001b[1mDuring: typing of call at /home/luna.kuleuven.be/u0166574/miniconda3/envs/crested_dev_torch/lib/python3.12/site-packages/tangermeme/tools/tomtom.py (341)\n",
+      "\u001b[0m\n",
+      "\u001b[0m\u001b[1mDuring: resolving callee type: type(CPUDispatcher(<function _p_values at 0x709694269f80>))\u001b[0m\n",
+      "\u001b[0m\u001b[1mDuring: typing of call at /home/luna.kuleuven.be/u0166574/miniconda3/envs/crested_dev_torch/lib/python3.12/site-packages/tangermeme/tools/tomtom.py (341)\n",
+      "\u001b[0m\n",
+      "\u001b[1m\n",
+      "File \"../../../miniconda3/envs/crested_dev_torch/lib/python3.12/site-packages/tangermeme/tools/tomtom.py\", line 341:\u001b[0m\n",
+      "\u001b[1mdef _tomtom(Q, T, Q_lens, T_lens, Q_norm, T_norm, rr_inv, rr_counts, n_nearest, \n",
+      "    <source elided>\n",
+      "\n",
+      "\u001b[1m\t\t_p_values(_gamma[pid], _B[pid], rr_inv, T_lens, nq, offset, \n",
+      "\u001b[0m  \u001b[1m^\u001b[0m\u001b[0m\n",
+      "\n",
+      "Warning: TOMTOM error while comparing patterns Astro_pos_patterns_3 and Astro_pos_patterns_1. Returning no match.\n",
+      "Error details: Failed in nopython mode pipeline (step: nopython frontend)\n",
+      "\u001b[1m\u001b[1m\u001b[1m\u001b[1mFailed in nopython mode pipeline (step: nopython frontend)\n",
+      "\u001b[1m\u001b[1mNo implementation of function Function(<built-in function iadd>) found for signature:\n",
+      " \n",
+      " >>> iadd(Literal[int](0), array(int32, 1d, C))\n",
+      " \n",
+      "There are 18 candidate implementations:\n",
+      "\u001b[1m     - Of which 16 did not match due to:\n",
+      "     Overload of function 'iadd': File: <numerous>: Line N/A.\n",
+      "       With argument(s): '(int64, array(int32, 1d, C))':\u001b[0m\n",
+      "\u001b[1m      No match.\u001b[0m\n",
+      "\u001b[1m     - Of which 2 did not match due to:\n",
+      "     Operator Overload in function 'iadd': File: unknown: Line unknown.\n",
+      "       With argument(s): '(int64, array(int32, 1d, C))':\u001b[0m\n",
+      "\u001b[1m      No match for registered cases:\n",
+      "       * (int64, int64) -> int64\n",
+      "       * (int64, uint64) -> int64\n",
+      "       * (uint64, int64) -> int64\n",
+      "       * (uint64, uint64) -> uint64\n",
+      "       * (float32, float32) -> float32\n",
+      "       * (float64, float64) -> float64\n",
+      "       * (complex64, complex64) -> complex64\n",
+      "       * (complex128, complex128) -> complex128\u001b[0m\n",
+      "\u001b[0m\n",
+      "\u001b[0m\u001b[1mDuring: typing of intrinsic-call at /home/luna.kuleuven.be/u0166574/miniconda3/envs/crested_dev_torch/lib/python3.12/site-packages/tangermeme/tools/tomtom.py (242)\u001b[0m\n",
+      "\u001b[1m\n",
+      "File \"../../../miniconda3/envs/crested_dev_torch/lib/python3.12/site-packages/tangermeme/tools/tomtom.py\", line 242:\u001b[0m\n",
+      "\u001b[1mdef _p_values(gamma, B_cdfs, rr_inv, T_lens, nq, offset, n_bins, results):\n",
+      "    <source elided>\n",
+      "\t\t\t\t\tj, t_idx = uint64(j), uint64(total_offset + j + k)\n",
+      "\u001b[1m\t\t\t\t\tscore += gamma[j, rr_inv[t_idx]]\n",
+      "\u001b[0m     \u001b[1m^\u001b[0m\u001b[0m\n",
+      "\n",
+      "\u001b[0m\u001b[1mDuring: resolving callee type: type(CPUDispatcher(<function _p_values at 0x709694269f80>))\u001b[0m\n",
+      "\u001b[0m\u001b[1mDuring: typing of call at /home/luna.kuleuven.be/u0166574/miniconda3/envs/crested_dev_torch/lib/python3.12/site-packages/tangermeme/tools/tomtom.py (341)\n",
+      "\u001b[0m\n",
+      "\u001b[0m\u001b[1mDuring: resolving callee type: type(CPUDispatcher(<function _p_values at 0x709694269f80>))\u001b[0m\n",
+      "\u001b[0m\u001b[1mDuring: typing of call at /home/luna.kuleuven.be/u0166574/miniconda3/envs/crested_dev_torch/lib/python3.12/site-packages/tangermeme/tools/tomtom.py (341)\n",
+      "\u001b[0m\n",
+      "\u001b[1m\n",
+      "File \"../../../miniconda3/envs/crested_dev_torch/lib/python3.12/site-packages/tangermeme/tools/tomtom.py\", line 341:\u001b[0m\n",
+      "\u001b[1mdef _tomtom(Q, T, Q_lens, T_lens, Q_norm, T_norm, rr_inv, rr_counts, n_nearest, \n",
+      "    <source elided>\n",
+      "\n",
+      "\u001b[1m\t\t_p_values(_gamma[pid], _B[pid], rr_inv, T_lens, nq, offset, \n",
+      "\u001b[0m  \u001b[1m^\u001b[0m\u001b[0m\n",
+      "\n",
+      "Warning: TOMTOM error while comparing patterns Astro_pos_patterns_2 and Astro_pos_patterns_3. Returning no match.\n",
+      "Error details: Failed in nopython mode pipeline (step: nopython frontend)\n",
+      "\u001b[1m\u001b[1m\u001b[1m\u001b[1mFailed in nopython mode pipeline (step: nopython frontend)\n",
+      "\u001b[1m\u001b[1mNo implementation of function Function(<built-in function iadd>) found for signature:\n",
+      " \n",
+      " >>> iadd(Literal[int](0), array(int32, 1d, C))\n",
+      " \n",
+      "There are 18 candidate implementations:\n",
+      "\u001b[1m     - Of which 16 did not match due to:\n",
+      "     Overload of function 'iadd': File: <numerous>: Line N/A.\n",
+      "       With argument(s): '(int64, array(int32, 1d, C))':\u001b[0m\n",
+      "\u001b[1m      No match.\u001b[0m\n",
+      "\u001b[1m     - Of which 2 did not match due to:\n",
+      "     Operator Overload in function 'iadd': File: unknown: Line unknown.\n",
+      "       With argument(s): '(int64, array(int32, 1d, C))':\u001b[0m\n",
+      "\u001b[1m      No match for registered cases:\n",
+      "       * (int64, int64) -> int64\n",
+      "       * (int64, uint64) -> int64\n",
+      "       * (uint64, int64) -> int64\n",
+      "       * (uint64, uint64) -> uint64\n",
+      "       * (float32, float32) -> float32\n",
+      "       * (float64, float64) -> float64\n",
+      "       * (complex64, complex64) -> complex64\n",
+      "       * (complex128, complex128) -> complex128\u001b[0m\n",
+      "\u001b[0m\n",
+      "\u001b[0m\u001b[1mDuring: typing of intrinsic-call at /home/luna.kuleuven.be/u0166574/miniconda3/envs/crested_dev_torch/lib/python3.12/site-packages/tangermeme/tools/tomtom.py (242)\u001b[0m\n",
+      "\u001b[1m\n",
+      "File \"../../../miniconda3/envs/crested_dev_torch/lib/python3.12/site-packages/tangermeme/tools/tomtom.py\", line 242:\u001b[0m\n",
+      "\u001b[1mdef _p_values(gamma, B_cdfs, rr_inv, T_lens, nq, offset, n_bins, results):\n",
+      "    <source elided>\n",
+      "\t\t\t\t\tj, t_idx = uint64(j), uint64(total_offset + j + k)\n",
+      "\u001b[1m\t\t\t\t\tscore += gamma[j, rr_inv[t_idx]]\n",
+      "\u001b[0m     \u001b[1m^\u001b[0m\u001b[0m\n",
+      "\n",
+      "\u001b[0m\u001b[1mDuring: resolving callee type: type(CPUDispatcher(<function _p_values at 0x709694269f80>))\u001b[0m\n",
+      "\u001b[0m\u001b[1mDuring: typing of call at /home/luna.kuleuven.be/u0166574/miniconda3/envs/crested_dev_torch/lib/python3.12/site-packages/tangermeme/tools/tomtom.py (341)\n",
+      "\u001b[0m\n",
+      "\u001b[0m\u001b[1mDuring: resolving callee type: type(CPUDispatcher(<function _p_values at 0x709694269f80>))\u001b[0m\n",
+      "\u001b[0m\u001b[1mDuring: typing of call at /home/luna.kuleuven.be/u0166574/miniconda3/envs/crested_dev_torch/lib/python3.12/site-packages/tangermeme/tools/tomtom.py (341)\n",
+      "\u001b[0m\n",
+      "\u001b[1m\n",
+      "File \"../../../miniconda3/envs/crested_dev_torch/lib/python3.12/site-packages/tangermeme/tools/tomtom.py\", line 341:\u001b[0m\n",
+      "\u001b[1mdef _tomtom(Q, T, Q_lens, T_lens, Q_norm, T_norm, rr_inv, rr_counts, n_nearest, \n",
+      "    <source elided>\n",
+      "\n",
+      "\u001b[1m\t\t_p_values(_gamma[pid], _B[pid], rr_inv, T_lens, nq, offset, \n",
+      "\u001b[0m  \u001b[1m^\u001b[0m\u001b[0m\n",
+      "\n",
+      "Warning: TOMTOM error while comparing patterns Astro_pos_patterns_3 and Astro_pos_patterns_2. Returning no match.\n",
+      "Error details: Failed in nopython mode pipeline (step: nopython frontend)\n",
+      "\u001b[1m\u001b[1m\u001b[1m\u001b[1mFailed in nopython mode pipeline (step: nopython frontend)\n",
+      "\u001b[1m\u001b[1mNo implementation of function Function(<built-in function iadd>) found for signature:\n",
+      " \n",
+      " >>> iadd(Literal[int](0), array(int32, 1d, C))\n",
+      " \n",
+      "There are 18 candidate implementations:\n",
+      "\u001b[1m     - Of which 16 did not match due to:\n",
+      "     Overload of function 'iadd': File: <numerous>: Line N/A.\n",
+      "       With argument(s): '(int64, array(int32, 1d, C))':\u001b[0m\n",
+      "\u001b[1m      No match.\u001b[0m\n",
+      "\u001b[1m     - Of which 2 did not match due to:\n",
+      "     Operator Overload in function 'iadd': File: unknown: Line unknown.\n",
+      "       With argument(s): '(int64, array(int32, 1d, C))':\u001b[0m\n",
+      "\u001b[1m      No match for registered cases:\n",
+      "       * (int64, int64) -> int64\n",
+      "       * (int64, uint64) -> int64\n",
+      "       * (uint64, int64) -> int64\n",
+      "       * (uint64, uint64) -> uint64\n",
+      "       * (float32, float32) -> float32\n",
+      "       * (float64, float64) -> float64\n",
+      "       * (complex64, complex64) -> complex64\n",
+      "       * (complex128, complex128) -> complex128\u001b[0m\n",
+      "\u001b[0m\n",
+      "\u001b[0m\u001b[1mDuring: typing of intrinsic-call at /home/luna.kuleuven.be/u0166574/miniconda3/envs/crested_dev_torch/lib/python3.12/site-packages/tangermeme/tools/tomtom.py (242)\u001b[0m\n",
+      "\u001b[1m\n",
+      "File \"../../../miniconda3/envs/crested_dev_torch/lib/python3.12/site-packages/tangermeme/tools/tomtom.py\", line 242:\u001b[0m\n",
+      "\u001b[1mdef _p_values(gamma, B_cdfs, rr_inv, T_lens, nq, offset, n_bins, results):\n",
+      "    <source elided>\n",
+      "\t\t\t\t\tj, t_idx = uint64(j), uint64(total_offset + j + k)\n",
+      "\u001b[1m\t\t\t\t\tscore += gamma[j, rr_inv[t_idx]]\n",
+      "\u001b[0m     \u001b[1m^\u001b[0m\u001b[0m\n",
+      "\n",
+      "\u001b[0m\u001b[1mDuring: resolving callee type: type(CPUDispatcher(<function _p_values at 0x709694269f80>))\u001b[0m\n",
+      "\u001b[0m\u001b[1mDuring: typing of call at /home/luna.kuleuven.be/u0166574/miniconda3/envs/crested_dev_torch/lib/python3.12/site-packages/tangermeme/tools/tomtom.py (341)\n",
+      "\u001b[0m\n",
+      "\u001b[0m\u001b[1mDuring: resolving callee type: type(CPUDispatcher(<function _p_values at 0x709694269f80>))\u001b[0m\n",
+      "\u001b[0m\u001b[1mDuring: typing of call at /home/luna.kuleuven.be/u0166574/miniconda3/envs/crested_dev_torch/lib/python3.12/site-packages/tangermeme/tools/tomtom.py (341)\n",
+      "\u001b[0m\n",
+      "\u001b[1m\n",
+      "File \"../../../miniconda3/envs/crested_dev_torch/lib/python3.12/site-packages/tangermeme/tools/tomtom.py\", line 341:\u001b[0m\n",
+      "\u001b[1mdef _tomtom(Q, T, Q_lens, T_lens, Q_norm, T_norm, rr_inv, rr_counts, n_nearest, \n",
+      "    <source elided>\n",
+      "\n",
+      "\u001b[1m\t\t_p_values(_gamma[pid], _B[pid], rr_inv, T_lens, nq, offset, \n",
+      "\u001b[0m  \u001b[1m^\u001b[0m\u001b[0m\n",
+      "\n",
+      "Discarded 0 patterns below IC threshold 0.2 and with a single class instance:\n",
+      "[]\n",
+      "Total iterations: 0\n",
+      "Warning: TOMTOM error while comparing patterns Astro_pos_patterns_0 and Astro_pos_patterns_1. Returning no match.\n",
+      "Error details: Failed in nopython mode pipeline (step: nopython frontend)\n",
+      "\u001b[1m\u001b[1m\u001b[1m\u001b[1mFailed in nopython mode pipeline (step: nopython frontend)\n",
+      "\u001b[1m\u001b[1mNo implementation of function Function(<built-in function iadd>) found for signature:\n",
+      " \n",
+      " >>> iadd(Literal[int](0), array(int32, 1d, C))\n",
+      " \n",
+      "There are 18 candidate implementations:\n",
+      "\u001b[1m     - Of which 16 did not match due to:\n",
+      "     Overload of function 'iadd': File: <numerous>: Line N/A.\n",
+      "       With argument(s): '(int64, array(int32, 1d, C))':\u001b[0m\n",
+      "\u001b[1m      No match.\u001b[0m\n",
+      "\u001b[1m     - Of which 2 did not match due to:\n",
+      "     Operator Overload in function 'iadd': File: unknown: Line unknown.\n",
+      "       With argument(s): '(int64, array(int32, 1d, C))':\u001b[0m\n",
+      "\u001b[1m      No match for registered cases:\n",
+      "       * (int64, int64) -> int64\n",
+      "       * (int64, uint64) -> int64\n",
+      "       * (uint64, int64) -> int64\n",
+      "       * (uint64, uint64) -> uint64\n",
+      "       * (float32, float32) -> float32\n",
+      "       * (float64, float64) -> float64\n",
+      "       * (complex64, complex64) -> complex64\n",
+      "       * (complex128, complex128) -> complex128\u001b[0m\n",
+      "\u001b[0m\n",
+      "\u001b[0m\u001b[1mDuring: typing of intrinsic-call at /home/luna.kuleuven.be/u0166574/miniconda3/envs/crested_dev_torch/lib/python3.12/site-packages/tangermeme/tools/tomtom.py (242)\u001b[0m\n",
+      "\u001b[1m\n",
+      "File \"../../../miniconda3/envs/crested_dev_torch/lib/python3.12/site-packages/tangermeme/tools/tomtom.py\", line 242:\u001b[0m\n",
+      "\u001b[1mdef _p_values(gamma, B_cdfs, rr_inv, T_lens, nq, offset, n_bins, results):\n",
+      "    <source elided>\n",
+      "\t\t\t\t\tj, t_idx = uint64(j), uint64(total_offset + j + k)\n",
+      "\u001b[1m\t\t\t\t\tscore += gamma[j, rr_inv[t_idx]]\n",
+      "\u001b[0m     \u001b[1m^\u001b[0m\u001b[0m\n",
+      "\n",
+      "\u001b[0m\u001b[1mDuring: resolving callee type: type(CPUDispatcher(<function _p_values at 0x709694269f80>))\u001b[0m\n",
+      "\u001b[0m\u001b[1mDuring: typing of call at /home/luna.kuleuven.be/u0166574/miniconda3/envs/crested_dev_torch/lib/python3.12/site-packages/tangermeme/tools/tomtom.py (341)\n",
+      "\u001b[0m\n",
+      "\u001b[0m\u001b[1mDuring: resolving callee type: type(CPUDispatcher(<function _p_values at 0x709694269f80>))\u001b[0m\n",
+      "\u001b[0m\u001b[1mDuring: typing of call at /home/luna.kuleuven.be/u0166574/miniconda3/envs/crested_dev_torch/lib/python3.12/site-packages/tangermeme/tools/tomtom.py (341)\n",
+      "\u001b[0m\n",
+      "\u001b[1m\n",
+      "File \"../../../miniconda3/envs/crested_dev_torch/lib/python3.12/site-packages/tangermeme/tools/tomtom.py\", line 341:\u001b[0m\n",
+      "\u001b[1mdef _tomtom(Q, T, Q_lens, T_lens, Q_norm, T_norm, rr_inv, rr_counts, n_nearest, \n",
+      "    <source elided>\n",
+      "\n",
+      "\u001b[1m\t\t_p_values(_gamma[pid], _B[pid], rr_inv, T_lens, nq, offset, \n",
+      "\u001b[0m  \u001b[1m^\u001b[0m\u001b[0m\n",
+      "\n",
+      "Warning: TOMTOM error while comparing patterns Astro_pos_patterns_1 and Astro_pos_patterns_0. Returning no match.\n",
+      "Error details: Failed in nopython mode pipeline (step: nopython frontend)\n",
+      "\u001b[1m\u001b[1m\u001b[1m\u001b[1mFailed in nopython mode pipeline (step: nopython frontend)\n",
+      "\u001b[1m\u001b[1mNo implementation of function Function(<built-in function iadd>) found for signature:\n",
+      " \n",
+      " >>> iadd(Literal[int](0), array(int32, 1d, C))\n",
+      " \n",
+      "There are 18 candidate implementations:\n",
+      "\u001b[1m     - Of which 16 did not match due to:\n",
+      "     Overload of function 'iadd': File: <numerous>: Line N/A.\n",
+      "       With argument(s): '(int64, array(int32, 1d, C))':\u001b[0m\n",
+      "\u001b[1m      No match.\u001b[0m\n",
+      "\u001b[1m     - Of which 2 did not match due to:\n",
+      "     Operator Overload in function 'iadd': File: unknown: Line unknown.\n",
+      "       With argument(s): '(int64, array(int32, 1d, C))':\u001b[0m\n",
+      "\u001b[1m      No match for registered cases:\n",
+      "       * (int64, int64) -> int64\n",
+      "       * (int64, uint64) -> int64\n",
+      "       * (uint64, int64) -> int64\n",
+      "       * (uint64, uint64) -> uint64\n",
+      "       * (float32, float32) -> float32\n",
+      "       * (float64, float64) -> float64\n",
+      "       * (complex64, complex64) -> complex64\n",
+      "       * (complex128, complex128) -> complex128\u001b[0m\n",
+      "\u001b[0m\n",
+      "\u001b[0m\u001b[1mDuring: typing of intrinsic-call at /home/luna.kuleuven.be/u0166574/miniconda3/envs/crested_dev_torch/lib/python3.12/site-packages/tangermeme/tools/tomtom.py (242)\u001b[0m\n",
+      "\u001b[1m\n",
+      "File \"../../../miniconda3/envs/crested_dev_torch/lib/python3.12/site-packages/tangermeme/tools/tomtom.py\", line 242:\u001b[0m\n",
+      "\u001b[1mdef _p_values(gamma, B_cdfs, rr_inv, T_lens, nq, offset, n_bins, results):\n",
+      "    <source elided>\n",
+      "\t\t\t\t\tj, t_idx = uint64(j), uint64(total_offset + j + k)\n",
+      "\u001b[1m\t\t\t\t\tscore += gamma[j, rr_inv[t_idx]]\n",
+      "\u001b[0m     \u001b[1m^\u001b[0m\u001b[0m\n",
+      "\n",
+      "\u001b[0m\u001b[1mDuring: resolving callee type: type(CPUDispatcher(<function _p_values at 0x709694269f80>))\u001b[0m\n",
+      "\u001b[0m\u001b[1mDuring: typing of call at /home/luna.kuleuven.be/u0166574/miniconda3/envs/crested_dev_torch/lib/python3.12/site-packages/tangermeme/tools/tomtom.py (341)\n",
+      "\u001b[0m\n",
+      "\u001b[0m\u001b[1mDuring: resolving callee type: type(CPUDispatcher(<function _p_values at 0x709694269f80>))\u001b[0m\n",
+      "\u001b[0m\u001b[1mDuring: typing of call at /home/luna.kuleuven.be/u0166574/miniconda3/envs/crested_dev_torch/lib/python3.12/site-packages/tangermeme/tools/tomtom.py (341)\n",
+      "\u001b[0m\n",
+      "\u001b[1m\n",
+      "File \"../../../miniconda3/envs/crested_dev_torch/lib/python3.12/site-packages/tangermeme/tools/tomtom.py\", line 341:\u001b[0m\n",
+      "\u001b[1mdef _tomtom(Q, T, Q_lens, T_lens, Q_norm, T_norm, rr_inv, rr_counts, n_nearest, \n",
+      "    <source elided>\n",
+      "\n",
+      "\u001b[1m\t\t_p_values(_gamma[pid], _B[pid], rr_inv, T_lens, nq, offset, \n",
+      "\u001b[0m  \u001b[1m^\u001b[0m\u001b[0m\n",
+      "\n",
+      "Warning: TOMTOM error while comparing patterns Astro_pos_patterns_0 and Astro_pos_patterns_2. Returning no match.\n",
+      "Error details: Failed in nopython mode pipeline (step: nopython frontend)\n",
+      "\u001b[1m\u001b[1m\u001b[1m\u001b[1mFailed in nopython mode pipeline (step: nopython frontend)\n",
+      "\u001b[1m\u001b[1mNo implementation of function Function(<built-in function iadd>) found for signature:\n",
+      " \n",
+      " >>> iadd(Literal[int](0), array(int32, 1d, C))\n",
+      " \n",
+      "There are 18 candidate implementations:\n",
+      "\u001b[1m     - Of which 16 did not match due to:\n",
+      "     Overload of function 'iadd': File: <numerous>: Line N/A.\n",
+      "       With argument(s): '(int64, array(int32, 1d, C))':\u001b[0m\n",
+      "\u001b[1m      No match.\u001b[0m\n",
+      "\u001b[1m     - Of which 2 did not match due to:\n",
+      "     Operator Overload in function 'iadd': File: unknown: Line unknown.\n",
+      "       With argument(s): '(int64, array(int32, 1d, C))':\u001b[0m\n",
+      "\u001b[1m      No match for registered cases:\n",
+      "       * (int64, int64) -> int64\n",
+      "       * (int64, uint64) -> int64\n",
+      "       * (uint64, int64) -> int64\n",
+      "       * (uint64, uint64) -> uint64\n",
+      "       * (float32, float32) -> float32\n",
+      "       * (float64, float64) -> float64\n",
+      "       * (complex64, complex64) -> complex64\n",
+      "       * (complex128, complex128) -> complex128\u001b[0m\n",
+      "\u001b[0m\n",
+      "\u001b[0m\u001b[1mDuring: typing of intrinsic-call at /home/luna.kuleuven.be/u0166574/miniconda3/envs/crested_dev_torch/lib/python3.12/site-packages/tangermeme/tools/tomtom.py (242)\u001b[0m\n",
+      "\u001b[1m\n",
+      "File \"../../../miniconda3/envs/crested_dev_torch/lib/python3.12/site-packages/tangermeme/tools/tomtom.py\", line 242:\u001b[0m\n",
+      "\u001b[1mdef _p_values(gamma, B_cdfs, rr_inv, T_lens, nq, offset, n_bins, results):\n",
+      "    <source elided>\n",
+      "\t\t\t\t\tj, t_idx = uint64(j), uint64(total_offset + j + k)\n",
+      "\u001b[1m\t\t\t\t\tscore += gamma[j, rr_inv[t_idx]]\n",
+      "\u001b[0m     \u001b[1m^\u001b[0m\u001b[0m\n",
+      "\n",
+      "\u001b[0m\u001b[1mDuring: resolving callee type: type(CPUDispatcher(<function _p_values at 0x709694269f80>))\u001b[0m\n",
+      "\u001b[0m\u001b[1mDuring: typing of call at /home/luna.kuleuven.be/u0166574/miniconda3/envs/crested_dev_torch/lib/python3.12/site-packages/tangermeme/tools/tomtom.py (341)\n",
+      "\u001b[0m\n",
+      "\u001b[0m\u001b[1mDuring: resolving callee type: type(CPUDispatcher(<function _p_values at 0x709694269f80>))\u001b[0m\n",
+      "\u001b[0m\u001b[1mDuring: typing of call at /home/luna.kuleuven.be/u0166574/miniconda3/envs/crested_dev_torch/lib/python3.12/site-packages/tangermeme/tools/tomtom.py (341)\n",
+      "\u001b[0m\n",
+      "\u001b[1m\n",
+      "File \"../../../miniconda3/envs/crested_dev_torch/lib/python3.12/site-packages/tangermeme/tools/tomtom.py\", line 341:\u001b[0m\n",
+      "\u001b[1mdef _tomtom(Q, T, Q_lens, T_lens, Q_norm, T_norm, rr_inv, rr_counts, n_nearest, \n",
+      "    <source elided>\n",
+      "\n",
+      "\u001b[1m\t\t_p_values(_gamma[pid], _B[pid], rr_inv, T_lens, nq, offset, \n",
+      "\u001b[0m  \u001b[1m^\u001b[0m\u001b[0m\n",
+      "\n",
+      "Warning: TOMTOM error while comparing patterns Astro_pos_patterns_2 and Astro_pos_patterns_0. Returning no match.\n",
+      "Error details: Failed in nopython mode pipeline (step: nopython frontend)\n",
+      "\u001b[1m\u001b[1m\u001b[1m\u001b[1mFailed in nopython mode pipeline (step: nopython frontend)\n",
+      "\u001b[1m\u001b[1mNo implementation of function Function(<built-in function iadd>) found for signature:\n",
+      " \n",
+      " >>> iadd(Literal[int](0), array(int32, 1d, C))\n",
+      " \n",
+      "There are 18 candidate implementations:\n",
+      "\u001b[1m     - Of which 16 did not match due to:\n",
+      "     Overload of function 'iadd': File: <numerous>: Line N/A.\n",
+      "       With argument(s): '(int64, array(int32, 1d, C))':\u001b[0m\n",
+      "\u001b[1m      No match.\u001b[0m\n",
+      "\u001b[1m     - Of which 2 did not match due to:\n",
+      "     Operator Overload in function 'iadd': File: unknown: Line unknown.\n",
+      "       With argument(s): '(int64, array(int32, 1d, C))':\u001b[0m\n",
+      "\u001b[1m      No match for registered cases:\n",
+      "       * (int64, int64) -> int64\n",
+      "       * (int64, uint64) -> int64\n",
+      "       * (uint64, int64) -> int64\n",
+      "       * (uint64, uint64) -> uint64\n",
+      "       * (float32, float32) -> float32\n",
+      "       * (float64, float64) -> float64\n",
+      "       * (complex64, complex64) -> complex64\n",
+      "       * (complex128, complex128) -> complex128\u001b[0m\n",
+      "\u001b[0m\n",
+      "\u001b[0m\u001b[1mDuring: typing of intrinsic-call at /home/luna.kuleuven.be/u0166574/miniconda3/envs/crested_dev_torch/lib/python3.12/site-packages/tangermeme/tools/tomtom.py (242)\u001b[0m\n",
+      "\u001b[1m\n",
+      "File \"../../../miniconda3/envs/crested_dev_torch/lib/python3.12/site-packages/tangermeme/tools/tomtom.py\", line 242:\u001b[0m\n",
+      "\u001b[1mdef _p_values(gamma, B_cdfs, rr_inv, T_lens, nq, offset, n_bins, results):\n",
+      "    <source elided>\n",
+      "\t\t\t\t\tj, t_idx = uint64(j), uint64(total_offset + j + k)\n",
+      "\u001b[1m\t\t\t\t\tscore += gamma[j, rr_inv[t_idx]]\n",
+      "\u001b[0m     \u001b[1m^\u001b[0m\u001b[0m\n",
+      "\n",
+      "\u001b[0m\u001b[1mDuring: resolving callee type: type(CPUDispatcher(<function _p_values at 0x709694269f80>))\u001b[0m\n",
+      "\u001b[0m\u001b[1mDuring: typing of call at /home/luna.kuleuven.be/u0166574/miniconda3/envs/crested_dev_torch/lib/python3.12/site-packages/tangermeme/tools/tomtom.py (341)\n",
+      "\u001b[0m\n",
+      "\u001b[0m\u001b[1mDuring: resolving callee type: type(CPUDispatcher(<function _p_values at 0x709694269f80>))\u001b[0m\n",
+      "\u001b[0m\u001b[1mDuring: typing of call at /home/luna.kuleuven.be/u0166574/miniconda3/envs/crested_dev_torch/lib/python3.12/site-packages/tangermeme/tools/tomtom.py (341)\n",
+      "\u001b[0m\n",
+      "\u001b[1m\n",
+      "File \"../../../miniconda3/envs/crested_dev_torch/lib/python3.12/site-packages/tangermeme/tools/tomtom.py\", line 341:\u001b[0m\n",
+      "\u001b[1mdef _tomtom(Q, T, Q_lens, T_lens, Q_norm, T_norm, rr_inv, rr_counts, n_nearest, \n",
+      "    <source elided>\n",
+      "\n",
+      "\u001b[1m\t\t_p_values(_gamma[pid], _B[pid], rr_inv, T_lens, nq, offset, \n",
+      "\u001b[0m  \u001b[1m^\u001b[0m\u001b[0m\n",
+      "\n",
+      "Warning: TOMTOM error while comparing patterns Astro_pos_patterns_0 and Astro_pos_patterns_3. Returning no match.\n",
+      "Error details: Failed in nopython mode pipeline (step: nopython frontend)\n",
+      "\u001b[1m\u001b[1m\u001b[1m\u001b[1mFailed in nopython mode pipeline (step: nopython frontend)\n",
+      "\u001b[1m\u001b[1mNo implementation of function Function(<built-in function iadd>) found for signature:\n",
+      " \n",
+      " >>> iadd(Literal[int](0), array(int32, 1d, C))\n",
+      " \n",
+      "There are 18 candidate implementations:\n",
+      "\u001b[1m     - Of which 16 did not match due to:\n",
+      "     Overload of function 'iadd': File: <numerous>: Line N/A.\n",
+      "       With argument(s): '(int64, array(int32, 1d, C))':\u001b[0m\n",
+      "\u001b[1m      No match.\u001b[0m\n",
+      "\u001b[1m     - Of which 2 did not match due to:\n",
+      "     Operator Overload in function 'iadd': File: unknown: Line unknown.\n",
+      "       With argument(s): '(int64, array(int32, 1d, C))':\u001b[0m\n",
+      "\u001b[1m      No match for registered cases:\n",
+      "       * (int64, int64) -> int64\n",
+      "       * (int64, uint64) -> int64\n",
+      "       * (uint64, int64) -> int64\n",
+      "       * (uint64, uint64) -> uint64\n",
+      "       * (float32, float32) -> float32\n",
+      "       * (float64, float64) -> float64\n",
+      "       * (complex64, complex64) -> complex64\n",
+      "       * (complex128, complex128) -> complex128\u001b[0m\n",
+      "\u001b[0m\n",
+      "\u001b[0m\u001b[1mDuring: typing of intrinsic-call at /home/luna.kuleuven.be/u0166574/miniconda3/envs/crested_dev_torch/lib/python3.12/site-packages/tangermeme/tools/tomtom.py (242)\u001b[0m\n",
+      "\u001b[1m\n",
+      "File \"../../../miniconda3/envs/crested_dev_torch/lib/python3.12/site-packages/tangermeme/tools/tomtom.py\", line 242:\u001b[0m\n",
+      "\u001b[1mdef _p_values(gamma, B_cdfs, rr_inv, T_lens, nq, offset, n_bins, results):\n",
+      "    <source elided>\n",
+      "\t\t\t\t\tj, t_idx = uint64(j), uint64(total_offset + j + k)\n",
+      "\u001b[1m\t\t\t\t\tscore += gamma[j, rr_inv[t_idx]]\n",
+      "\u001b[0m     \u001b[1m^\u001b[0m\u001b[0m\n",
+      "\n",
+      "\u001b[0m\u001b[1mDuring: resolving callee type: type(CPUDispatcher(<function _p_values at 0x709694269f80>))\u001b[0m\n",
+      "\u001b[0m\u001b[1mDuring: typing of call at /home/luna.kuleuven.be/u0166574/miniconda3/envs/crested_dev_torch/lib/python3.12/site-packages/tangermeme/tools/tomtom.py (341)\n",
+      "\u001b[0m\n",
+      "\u001b[0m\u001b[1mDuring: resolving callee type: type(CPUDispatcher(<function _p_values at 0x709694269f80>))\u001b[0m\n",
+      "\u001b[0m\u001b[1mDuring: typing of call at /home/luna.kuleuven.be/u0166574/miniconda3/envs/crested_dev_torch/lib/python3.12/site-packages/tangermeme/tools/tomtom.py (341)\n",
+      "\u001b[0m\n",
+      "\u001b[1m\n",
+      "File \"../../../miniconda3/envs/crested_dev_torch/lib/python3.12/site-packages/tangermeme/tools/tomtom.py\", line 341:\u001b[0m\n",
+      "\u001b[1mdef _tomtom(Q, T, Q_lens, T_lens, Q_norm, T_norm, rr_inv, rr_counts, n_nearest, \n",
+      "    <source elided>\n",
+      "\n",
+      "\u001b[1m\t\t_p_values(_gamma[pid], _B[pid], rr_inv, T_lens, nq, offset, \n",
+      "\u001b[0m  \u001b[1m^\u001b[0m\u001b[0m\n",
+      "\n",
+      "Warning: TOMTOM error while comparing patterns Astro_pos_patterns_3 and Astro_pos_patterns_0. Returning no match.\n",
+      "Error details: Failed in nopython mode pipeline (step: nopython frontend)\n",
+      "\u001b[1m\u001b[1m\u001b[1m\u001b[1mFailed in nopython mode pipeline (step: nopython frontend)\n",
+      "\u001b[1m\u001b[1mNo implementation of function Function(<built-in function iadd>) found for signature:\n",
+      " \n",
+      " >>> iadd(Literal[int](0), array(int32, 1d, C))\n",
+      " \n",
+      "There are 18 candidate implementations:\n",
+      "\u001b[1m     - Of which 16 did not match due to:\n",
+      "     Overload of function 'iadd': File: <numerous>: Line N/A.\n",
+      "       With argument(s): '(int64, array(int32, 1d, C))':\u001b[0m\n",
+      "\u001b[1m      No match.\u001b[0m\n",
+      "\u001b[1m     - Of which 2 did not match due to:\n",
+      "     Operator Overload in function 'iadd': File: unknown: Line unknown.\n",
+      "       With argument(s): '(int64, array(int32, 1d, C))':\u001b[0m\n",
+      "\u001b[1m      No match for registered cases:\n",
+      "       * (int64, int64) -> int64\n",
+      "       * (int64, uint64) -> int64\n",
+      "       * (uint64, int64) -> int64\n",
+      "       * (uint64, uint64) -> uint64\n",
+      "       * (float32, float32) -> float32\n",
+      "       * (float64, float64) -> float64\n",
+      "       * (complex64, complex64) -> complex64\n",
+      "       * (complex128, complex128) -> complex128\u001b[0m\n",
+      "\u001b[0m\n",
+      "\u001b[0m\u001b[1mDuring: typing of intrinsic-call at /home/luna.kuleuven.be/u0166574/miniconda3/envs/crested_dev_torch/lib/python3.12/site-packages/tangermeme/tools/tomtom.py (242)\u001b[0m\n",
+      "\u001b[1m\n",
+      "File \"../../../miniconda3/envs/crested_dev_torch/lib/python3.12/site-packages/tangermeme/tools/tomtom.py\", line 242:\u001b[0m\n",
+      "\u001b[1mdef _p_values(gamma, B_cdfs, rr_inv, T_lens, nq, offset, n_bins, results):\n",
+      "    <source elided>\n",
+      "\t\t\t\t\tj, t_idx = uint64(j), uint64(total_offset + j + k)\n",
+      "\u001b[1m\t\t\t\t\tscore += gamma[j, rr_inv[t_idx]]\n",
+      "\u001b[0m     \u001b[1m^\u001b[0m\u001b[0m\n",
+      "\n",
+      "\u001b[0m\u001b[1mDuring: resolving callee type: type(CPUDispatcher(<function _p_values at 0x709694269f80>))\u001b[0m\n",
+      "\u001b[0m\u001b[1mDuring: typing of call at /home/luna.kuleuven.be/u0166574/miniconda3/envs/crested_dev_torch/lib/python3.12/site-packages/tangermeme/tools/tomtom.py (341)\n",
+      "\u001b[0m\n",
+      "\u001b[0m\u001b[1mDuring: resolving callee type: type(CPUDispatcher(<function _p_values at 0x709694269f80>))\u001b[0m\n",
+      "\u001b[0m\u001b[1mDuring: typing of call at /home/luna.kuleuven.be/u0166574/miniconda3/envs/crested_dev_torch/lib/python3.12/site-packages/tangermeme/tools/tomtom.py (341)\n",
+      "\u001b[0m\n",
+      "\u001b[1m\n",
+      "File \"../../../miniconda3/envs/crested_dev_torch/lib/python3.12/site-packages/tangermeme/tools/tomtom.py\", line 341:\u001b[0m\n",
+      "\u001b[1mdef _tomtom(Q, T, Q_lens, T_lens, Q_norm, T_norm, rr_inv, rr_counts, n_nearest, \n",
+      "    <source elided>\n",
+      "\n",
+      "\u001b[1m\t\t_p_values(_gamma[pid], _B[pid], rr_inv, T_lens, nq, offset, \n",
+      "\u001b[0m  \u001b[1m^\u001b[0m\u001b[0m\n",
+      "\n",
+      "Warning: TOMTOM error while comparing patterns Astro_pos_patterns_1 and Astro_pos_patterns_2. Returning no match.\n",
+      "Error details: Failed in nopython mode pipeline (step: nopython frontend)\n",
+      "\u001b[1m\u001b[1m\u001b[1m\u001b[1mFailed in nopython mode pipeline (step: nopython frontend)\n",
+      "\u001b[1m\u001b[1mNo implementation of function Function(<built-in function iadd>) found for signature:\n",
+      " \n",
+      " >>> iadd(Literal[int](0), array(int32, 1d, C))\n",
+      " \n",
+      "There are 18 candidate implementations:\n",
+      "\u001b[1m     - Of which 16 did not match due to:\n",
+      "     Overload of function 'iadd': File: <numerous>: Line N/A.\n",
+      "       With argument(s): '(int64, array(int32, 1d, C))':\u001b[0m\n",
+      "\u001b[1m      No match.\u001b[0m\n",
+      "\u001b[1m     - Of which 2 did not match due to:\n",
+      "     Operator Overload in function 'iadd': File: unknown: Line unknown.\n",
+      "       With argument(s): '(int64, array(int32, 1d, C))':\u001b[0m\n",
+      "\u001b[1m      No match for registered cases:\n",
+      "       * (int64, int64) -> int64\n",
+      "       * (int64, uint64) -> int64\n",
+      "       * (uint64, int64) -> int64\n",
+      "       * (uint64, uint64) -> uint64\n",
+      "       * (float32, float32) -> float32\n",
+      "       * (float64, float64) -> float64\n",
+      "       * (complex64, complex64) -> complex64\n",
+      "       * (complex128, complex128) -> complex128\u001b[0m\n",
+      "\u001b[0m\n",
+      "\u001b[0m\u001b[1mDuring: typing of intrinsic-call at /home/luna.kuleuven.be/u0166574/miniconda3/envs/crested_dev_torch/lib/python3.12/site-packages/tangermeme/tools/tomtom.py (242)\u001b[0m\n",
+      "\u001b[1m\n",
+      "File \"../../../miniconda3/envs/crested_dev_torch/lib/python3.12/site-packages/tangermeme/tools/tomtom.py\", line 242:\u001b[0m\n",
+      "\u001b[1mdef _p_values(gamma, B_cdfs, rr_inv, T_lens, nq, offset, n_bins, results):\n",
+      "    <source elided>\n",
+      "\t\t\t\t\tj, t_idx = uint64(j), uint64(total_offset + j + k)\n",
+      "\u001b[1m\t\t\t\t\tscore += gamma[j, rr_inv[t_idx]]\n",
+      "\u001b[0m     \u001b[1m^\u001b[0m\u001b[0m\n",
+      "\n",
+      "\u001b[0m\u001b[1mDuring: resolving callee type: type(CPUDispatcher(<function _p_values at 0x709694269f80>))\u001b[0m\n",
+      "\u001b[0m\u001b[1mDuring: typing of call at /home/luna.kuleuven.be/u0166574/miniconda3/envs/crested_dev_torch/lib/python3.12/site-packages/tangermeme/tools/tomtom.py (341)\n",
+      "\u001b[0m\n",
+      "\u001b[0m\u001b[1mDuring: resolving callee type: type(CPUDispatcher(<function _p_values at 0x709694269f80>))\u001b[0m\n",
+      "\u001b[0m\u001b[1mDuring: typing of call at /home/luna.kuleuven.be/u0166574/miniconda3/envs/crested_dev_torch/lib/python3.12/site-packages/tangermeme/tools/tomtom.py (341)\n",
+      "\u001b[0m\n",
+      "\u001b[1m\n",
+      "File \"../../../miniconda3/envs/crested_dev_torch/lib/python3.12/site-packages/tangermeme/tools/tomtom.py\", line 341:\u001b[0m\n",
+      "\u001b[1mdef _tomtom(Q, T, Q_lens, T_lens, Q_norm, T_norm, rr_inv, rr_counts, n_nearest, \n",
+      "    <source elided>\n",
+      "\n",
+      "\u001b[1m\t\t_p_values(_gamma[pid], _B[pid], rr_inv, T_lens, nq, offset, \n",
+      "\u001b[0m  \u001b[1m^\u001b[0m\u001b[0m\n",
+      "\n",
+      "Warning: TOMTOM error while comparing patterns Astro_pos_patterns_2 and Astro_pos_patterns_1. Returning no match.\n",
+      "Error details: Failed in nopython mode pipeline (step: nopython frontend)\n",
+      "\u001b[1m\u001b[1m\u001b[1m\u001b[1mFailed in nopython mode pipeline (step: nopython frontend)\n",
+      "\u001b[1m\u001b[1mNo implementation of function Function(<built-in function iadd>) found for signature:\n",
+      " \n",
+      " >>> iadd(Literal[int](0), array(int32, 1d, C))\n",
+      " \n",
+      "There are 18 candidate implementations:\n",
+      "\u001b[1m     - Of which 16 did not match due to:\n",
+      "     Overload of function 'iadd': File: <numerous>: Line N/A.\n",
+      "       With argument(s): '(int64, array(int32, 1d, C))':\u001b[0m\n",
+      "\u001b[1m      No match.\u001b[0m\n",
+      "\u001b[1m     - Of which 2 did not match due to:\n",
+      "     Operator Overload in function 'iadd': File: unknown: Line unknown.\n",
+      "       With argument(s): '(int64, array(int32, 1d, C))':\u001b[0m\n",
+      "\u001b[1m      No match for registered cases:\n",
+      "       * (int64, int64) -> int64\n",
+      "       * (int64, uint64) -> int64\n",
+      "       * (uint64, int64) -> int64\n",
+      "       * (uint64, uint64) -> uint64\n",
+      "       * (float32, float32) -> float32\n",
+      "       * (float64, float64) -> float64\n",
+      "       * (complex64, complex64) -> complex64\n",
+      "       * (complex128, complex128) -> complex128\u001b[0m\n",
+      "\u001b[0m\n",
+      "\u001b[0m\u001b[1mDuring: typing of intrinsic-call at /home/luna.kuleuven.be/u0166574/miniconda3/envs/crested_dev_torch/lib/python3.12/site-packages/tangermeme/tools/tomtom.py (242)\u001b[0m\n",
+      "\u001b[1m\n",
+      "File \"../../../miniconda3/envs/crested_dev_torch/lib/python3.12/site-packages/tangermeme/tools/tomtom.py\", line 242:\u001b[0m\n",
+      "\u001b[1mdef _p_values(gamma, B_cdfs, rr_inv, T_lens, nq, offset, n_bins, results):\n",
+      "    <source elided>\n",
+      "\t\t\t\t\tj, t_idx = uint64(j), uint64(total_offset + j + k)\n",
+      "\u001b[1m\t\t\t\t\tscore += gamma[j, rr_inv[t_idx]]\n",
+      "\u001b[0m     \u001b[1m^\u001b[0m\u001b[0m\n",
+      "\n",
+      "\u001b[0m\u001b[1mDuring: resolving callee type: type(CPUDispatcher(<function _p_values at 0x709694269f80>))\u001b[0m\n",
+      "\u001b[0m\u001b[1mDuring: typing of call at /home/luna.kuleuven.be/u0166574/miniconda3/envs/crested_dev_torch/lib/python3.12/site-packages/tangermeme/tools/tomtom.py (341)\n",
+      "\u001b[0m\n",
+      "\u001b[0m\u001b[1mDuring: resolving callee type: type(CPUDispatcher(<function _p_values at 0x709694269f80>))\u001b[0m\n",
+      "\u001b[0m\u001b[1mDuring: typing of call at /home/luna.kuleuven.be/u0166574/miniconda3/envs/crested_dev_torch/lib/python3.12/site-packages/tangermeme/tools/tomtom.py (341)\n",
+      "\u001b[0m\n",
+      "\u001b[1m\n",
+      "File \"../../../miniconda3/envs/crested_dev_torch/lib/python3.12/site-packages/tangermeme/tools/tomtom.py\", line 341:\u001b[0m\n",
+      "\u001b[1mdef _tomtom(Q, T, Q_lens, T_lens, Q_norm, T_norm, rr_inv, rr_counts, n_nearest, \n",
+      "    <source elided>\n",
+      "\n",
+      "\u001b[1m\t\t_p_values(_gamma[pid], _B[pid], rr_inv, T_lens, nq, offset, \n",
+      "\u001b[0m  \u001b[1m^\u001b[0m\u001b[0m\n",
+      "\n",
+      "Warning: TOMTOM error while comparing patterns Astro_pos_patterns_1 and Astro_pos_patterns_3. Returning no match.\n",
+      "Error details: Failed in nopython mode pipeline (step: nopython frontend)\n",
+      "\u001b[1m\u001b[1m\u001b[1m\u001b[1mFailed in nopython mode pipeline (step: nopython frontend)\n",
+      "\u001b[1m\u001b[1mNo implementation of function Function(<built-in function iadd>) found for signature:\n",
+      " \n",
+      " >>> iadd(Literal[int](0), array(int32, 1d, C))\n",
+      " \n",
+      "There are 18 candidate implementations:\n",
+      "\u001b[1m     - Of which 16 did not match due to:\n",
+      "     Overload of function 'iadd': File: <numerous>: Line N/A.\n",
+      "       With argument(s): '(int64, array(int32, 1d, C))':\u001b[0m\n",
+      "\u001b[1m      No match.\u001b[0m\n",
+      "\u001b[1m     - Of which 2 did not match due to:\n",
+      "     Operator Overload in function 'iadd': File: unknown: Line unknown.\n",
+      "       With argument(s): '(int64, array(int32, 1d, C))':\u001b[0m\n",
+      "\u001b[1m      No match for registered cases:\n",
+      "       * (int64, int64) -> int64\n",
+      "       * (int64, uint64) -> int64\n",
+      "       * (uint64, int64) -> int64\n",
+      "       * (uint64, uint64) -> uint64\n",
+      "       * (float32, float32) -> float32\n",
+      "       * (float64, float64) -> float64\n",
+      "       * (complex64, complex64) -> complex64\n",
+      "       * (complex128, complex128) -> complex128\u001b[0m\n",
+      "\u001b[0m\n",
+      "\u001b[0m\u001b[1mDuring: typing of intrinsic-call at /home/luna.kuleuven.be/u0166574/miniconda3/envs/crested_dev_torch/lib/python3.12/site-packages/tangermeme/tools/tomtom.py (242)\u001b[0m\n",
+      "\u001b[1m\n",
+      "File \"../../../miniconda3/envs/crested_dev_torch/lib/python3.12/site-packages/tangermeme/tools/tomtom.py\", line 242:\u001b[0m\n",
+      "\u001b[1mdef _p_values(gamma, B_cdfs, rr_inv, T_lens, nq, offset, n_bins, results):\n",
+      "    <source elided>\n",
+      "\t\t\t\t\tj, t_idx = uint64(j), uint64(total_offset + j + k)\n",
+      "\u001b[1m\t\t\t\t\tscore += gamma[j, rr_inv[t_idx]]\n",
+      "\u001b[0m     \u001b[1m^\u001b[0m\u001b[0m\n",
+      "\n",
+      "\u001b[0m\u001b[1mDuring: resolving callee type: type(CPUDispatcher(<function _p_values at 0x709694269f80>))\u001b[0m\n",
+      "\u001b[0m\u001b[1mDuring: typing of call at /home/luna.kuleuven.be/u0166574/miniconda3/envs/crested_dev_torch/lib/python3.12/site-packages/tangermeme/tools/tomtom.py (341)\n",
+      "\u001b[0m\n",
+      "\u001b[0m\u001b[1mDuring: resolving callee type: type(CPUDispatcher(<function _p_values at 0x709694269f80>))\u001b[0m\n",
+      "\u001b[0m\u001b[1mDuring: typing of call at /home/luna.kuleuven.be/u0166574/miniconda3/envs/crested_dev_torch/lib/python3.12/site-packages/tangermeme/tools/tomtom.py (341)\n",
+      "\u001b[0m\n",
+      "\u001b[1m\n",
+      "File \"../../../miniconda3/envs/crested_dev_torch/lib/python3.12/site-packages/tangermeme/tools/tomtom.py\", line 341:\u001b[0m\n",
+      "\u001b[1mdef _tomtom(Q, T, Q_lens, T_lens, Q_norm, T_norm, rr_inv, rr_counts, n_nearest, \n",
+      "    <source elided>\n",
+      "\n",
+      "\u001b[1m\t\t_p_values(_gamma[pid], _B[pid], rr_inv, T_lens, nq, offset, \n",
+      "\u001b[0m  \u001b[1m^\u001b[0m\u001b[0m\n",
+      "\n",
+      "Warning: TOMTOM error while comparing patterns Astro_pos_patterns_3 and Astro_pos_patterns_1. Returning no match.\n",
+      "Error details: Failed in nopython mode pipeline (step: nopython frontend)\n",
+      "\u001b[1m\u001b[1m\u001b[1m\u001b[1mFailed in nopython mode pipeline (step: nopython frontend)\n",
+      "\u001b[1m\u001b[1mNo implementation of function Function(<built-in function iadd>) found for signature:\n",
+      " \n",
+      " >>> iadd(Literal[int](0), array(int32, 1d, C))\n",
+      " \n",
+      "There are 18 candidate implementations:\n",
+      "\u001b[1m     - Of which 16 did not match due to:\n",
+      "     Overload of function 'iadd': File: <numerous>: Line N/A.\n",
+      "       With argument(s): '(int64, array(int32, 1d, C))':\u001b[0m\n",
+      "\u001b[1m      No match.\u001b[0m\n",
+      "\u001b[1m     - Of which 2 did not match due to:\n",
+      "     Operator Overload in function 'iadd': File: unknown: Line unknown.\n",
+      "       With argument(s): '(int64, array(int32, 1d, C))':\u001b[0m\n",
+      "\u001b[1m      No match for registered cases:\n",
+      "       * (int64, int64) -> int64\n",
+      "       * (int64, uint64) -> int64\n",
+      "       * (uint64, int64) -> int64\n",
+      "       * (uint64, uint64) -> uint64\n",
+      "       * (float32, float32) -> float32\n",
+      "       * (float64, float64) -> float64\n",
+      "       * (complex64, complex64) -> complex64\n",
+      "       * (complex128, complex128) -> complex128\u001b[0m\n",
+      "\u001b[0m\n",
+      "\u001b[0m\u001b[1mDuring: typing of intrinsic-call at /home/luna.kuleuven.be/u0166574/miniconda3/envs/crested_dev_torch/lib/python3.12/site-packages/tangermeme/tools/tomtom.py (242)\u001b[0m\n",
+      "\u001b[1m\n",
+      "File \"../../../miniconda3/envs/crested_dev_torch/lib/python3.12/site-packages/tangermeme/tools/tomtom.py\", line 242:\u001b[0m\n",
+      "\u001b[1mdef _p_values(gamma, B_cdfs, rr_inv, T_lens, nq, offset, n_bins, results):\n",
+      "    <source elided>\n",
+      "\t\t\t\t\tj, t_idx = uint64(j), uint64(total_offset + j + k)\n",
+      "\u001b[1m\t\t\t\t\tscore += gamma[j, rr_inv[t_idx]]\n",
+      "\u001b[0m     \u001b[1m^\u001b[0m\u001b[0m\n",
+      "\n",
+      "\u001b[0m\u001b[1mDuring: resolving callee type: type(CPUDispatcher(<function _p_values at 0x709694269f80>))\u001b[0m\n",
+      "\u001b[0m\u001b[1mDuring: typing of call at /home/luna.kuleuven.be/u0166574/miniconda3/envs/crested_dev_torch/lib/python3.12/site-packages/tangermeme/tools/tomtom.py (341)\n",
+      "\u001b[0m\n",
+      "\u001b[0m\u001b[1mDuring: resolving callee type: type(CPUDispatcher(<function _p_values at 0x709694269f80>))\u001b[0m\n",
+      "\u001b[0m\u001b[1mDuring: typing of call at /home/luna.kuleuven.be/u0166574/miniconda3/envs/crested_dev_torch/lib/python3.12/site-packages/tangermeme/tools/tomtom.py (341)\n",
+      "\u001b[0m\n",
+      "\u001b[1m\n",
+      "File \"../../../miniconda3/envs/crested_dev_torch/lib/python3.12/site-packages/tangermeme/tools/tomtom.py\", line 341:\u001b[0m\n",
+      "\u001b[1mdef _tomtom(Q, T, Q_lens, T_lens, Q_norm, T_norm, rr_inv, rr_counts, n_nearest, \n",
+      "    <source elided>\n",
+      "\n",
+      "\u001b[1m\t\t_p_values(_gamma[pid], _B[pid], rr_inv, T_lens, nq, offset, \n",
+      "\u001b[0m  \u001b[1m^\u001b[0m\u001b[0m\n",
+      "\n",
+      "Warning: TOMTOM error while comparing patterns Astro_pos_patterns_2 and Astro_pos_patterns_3. Returning no match.\n",
+      "Error details: Failed in nopython mode pipeline (step: nopython frontend)\n",
+      "\u001b[1m\u001b[1m\u001b[1m\u001b[1mFailed in nopython mode pipeline (step: nopython frontend)\n",
+      "\u001b[1m\u001b[1mNo implementation of function Function(<built-in function iadd>) found for signature:\n",
+      " \n",
+      " >>> iadd(Literal[int](0), array(int32, 1d, C))\n",
+      " \n",
+      "There are 18 candidate implementations:\n",
+      "\u001b[1m     - Of which 16 did not match due to:\n",
+      "     Overload of function 'iadd': File: <numerous>: Line N/A.\n",
+      "       With argument(s): '(int64, array(int32, 1d, C))':\u001b[0m\n",
+      "\u001b[1m      No match.\u001b[0m\n",
+      "\u001b[1m     - Of which 2 did not match due to:\n",
+      "     Operator Overload in function 'iadd': File: unknown: Line unknown.\n",
+      "       With argument(s): '(int64, array(int32, 1d, C))':\u001b[0m\n",
+      "\u001b[1m      No match for registered cases:\n",
+      "       * (int64, int64) -> int64\n",
+      "       * (int64, uint64) -> int64\n",
+      "       * (uint64, int64) -> int64\n",
+      "       * (uint64, uint64) -> uint64\n",
+      "       * (float32, float32) -> float32\n",
+      "       * (float64, float64) -> float64\n",
+      "       * (complex64, complex64) -> complex64\n",
+      "       * (complex128, complex128) -> complex128\u001b[0m\n",
+      "\u001b[0m\n",
+      "\u001b[0m\u001b[1mDuring: typing of intrinsic-call at /home/luna.kuleuven.be/u0166574/miniconda3/envs/crested_dev_torch/lib/python3.12/site-packages/tangermeme/tools/tomtom.py (242)\u001b[0m\n",
+      "\u001b[1m\n",
+      "File \"../../../miniconda3/envs/crested_dev_torch/lib/python3.12/site-packages/tangermeme/tools/tomtom.py\", line 242:\u001b[0m\n",
+      "\u001b[1mdef _p_values(gamma, B_cdfs, rr_inv, T_lens, nq, offset, n_bins, results):\n",
+      "    <source elided>\n",
+      "\t\t\t\t\tj, t_idx = uint64(j), uint64(total_offset + j + k)\n",
+      "\u001b[1m\t\t\t\t\tscore += gamma[j, rr_inv[t_idx]]\n",
+      "\u001b[0m     \u001b[1m^\u001b[0m\u001b[0m\n",
+      "\n",
+      "\u001b[0m\u001b[1mDuring: resolving callee type: type(CPUDispatcher(<function _p_values at 0x709694269f80>))\u001b[0m\n",
+      "\u001b[0m\u001b[1mDuring: typing of call at /home/luna.kuleuven.be/u0166574/miniconda3/envs/crested_dev_torch/lib/python3.12/site-packages/tangermeme/tools/tomtom.py (341)\n",
+      "\u001b[0m\n",
+      "\u001b[0m\u001b[1mDuring: resolving callee type: type(CPUDispatcher(<function _p_values at 0x709694269f80>))\u001b[0m\n",
+      "\u001b[0m\u001b[1mDuring: typing of call at /home/luna.kuleuven.be/u0166574/miniconda3/envs/crested_dev_torch/lib/python3.12/site-packages/tangermeme/tools/tomtom.py (341)\n",
+      "\u001b[0m\n",
+      "\u001b[1m\n",
+      "File \"../../../miniconda3/envs/crested_dev_torch/lib/python3.12/site-packages/tangermeme/tools/tomtom.py\", line 341:\u001b[0m\n",
+      "\u001b[1mdef _tomtom(Q, T, Q_lens, T_lens, Q_norm, T_norm, rr_inv, rr_counts, n_nearest, \n",
+      "    <source elided>\n",
+      "\n",
+      "\u001b[1m\t\t_p_values(_gamma[pid], _B[pid], rr_inv, T_lens, nq, offset, \n",
+      "\u001b[0m  \u001b[1m^\u001b[0m\u001b[0m\n",
+      "\n",
+      "Warning: TOMTOM error while comparing patterns Astro_pos_patterns_3 and Astro_pos_patterns_2. Returning no match.\n",
+      "Error details: Failed in nopython mode pipeline (step: nopython frontend)\n",
+      "\u001b[1m\u001b[1m\u001b[1m\u001b[1mFailed in nopython mode pipeline (step: nopython frontend)\n",
+      "\u001b[1m\u001b[1mNo implementation of function Function(<built-in function iadd>) found for signature:\n",
+      " \n",
+      " >>> iadd(Literal[int](0), array(int32, 1d, C))\n",
+      " \n",
+      "There are 18 candidate implementations:\n",
+      "\u001b[1m     - Of which 16 did not match due to:\n",
+      "     Overload of function 'iadd': File: <numerous>: Line N/A.\n",
+      "       With argument(s): '(int64, array(int32, 1d, C))':\u001b[0m\n",
+      "\u001b[1m      No match.\u001b[0m\n",
+      "\u001b[1m     - Of which 2 did not match due to:\n",
+      "     Operator Overload in function 'iadd': File: unknown: Line unknown.\n",
+      "       With argument(s): '(int64, array(int32, 1d, C))':\u001b[0m\n",
+      "\u001b[1m      No match for registered cases:\n",
+      "       * (int64, int64) -> int64\n",
+      "       * (int64, uint64) -> int64\n",
+      "       * (uint64, int64) -> int64\n",
+      "       * (uint64, uint64) -> uint64\n",
+      "       * (float32, float32) -> float32\n",
+      "       * (float64, float64) -> float64\n",
+      "       * (complex64, complex64) -> complex64\n",
+      "       * (complex128, complex128) -> complex128\u001b[0m\n",
+      "\u001b[0m\n",
+      "\u001b[0m\u001b[1mDuring: typing of intrinsic-call at /home/luna.kuleuven.be/u0166574/miniconda3/envs/crested_dev_torch/lib/python3.12/site-packages/tangermeme/tools/tomtom.py (242)\u001b[0m\n",
+      "\u001b[1m\n",
+      "File \"../../../miniconda3/envs/crested_dev_torch/lib/python3.12/site-packages/tangermeme/tools/tomtom.py\", line 242:\u001b[0m\n",
+      "\u001b[1mdef _p_values(gamma, B_cdfs, rr_inv, T_lens, nq, offset, n_bins, results):\n",
+      "    <source elided>\n",
+      "\t\t\t\t\tj, t_idx = uint64(j), uint64(total_offset + j + k)\n",
+      "\u001b[1m\t\t\t\t\tscore += gamma[j, rr_inv[t_idx]]\n",
+      "\u001b[0m     \u001b[1m^\u001b[0m\u001b[0m\n",
+      "\n",
+      "\u001b[0m\u001b[1mDuring: resolving callee type: type(CPUDispatcher(<function _p_values at 0x709694269f80>))\u001b[0m\n",
+      "\u001b[0m\u001b[1mDuring: typing of call at /home/luna.kuleuven.be/u0166574/miniconda3/envs/crested_dev_torch/lib/python3.12/site-packages/tangermeme/tools/tomtom.py (341)\n",
+      "\u001b[0m\n",
+      "\u001b[0m\u001b[1mDuring: resolving callee type: type(CPUDispatcher(<function _p_values at 0x709694269f80>))\u001b[0m\n",
+      "\u001b[0m\u001b[1mDuring: typing of call at /home/luna.kuleuven.be/u0166574/miniconda3/envs/crested_dev_torch/lib/python3.12/site-packages/tangermeme/tools/tomtom.py (341)\n",
+      "\u001b[0m\n",
+      "\u001b[1m\n",
+      "File \"../../../miniconda3/envs/crested_dev_torch/lib/python3.12/site-packages/tangermeme/tools/tomtom.py\", line 341:\u001b[0m\n",
+      "\u001b[1mdef _tomtom(Q, T, Q_lens, T_lens, Q_norm, T_norm, rr_inv, rr_counts, n_nearest, \n",
+      "    <source elided>\n",
+      "\n",
+      "\u001b[1m\t\t_p_values(_gamma[pid], _B[pid], rr_inv, T_lens, nq, offset, \n",
+      "\u001b[0m  \u001b[1m^\u001b[0m\u001b[0m\n",
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "all_patterns = crested.tl.modisco.process_patterns(\n",
+    "    matched_files,\n",
+    "    sim_threshold=1.5,  # The similarity threshold used for matching patterns. We take the -log10(pval), pval obtained through TOMTOM matching from tangermeme\n",
+    "    trim_ic_threshold=0.1,  # Information content (IC) threshold on which to trim patterns\n",
+    "    discard_ic_threshold=0.2,  # IC threshold used for discarding single instance patterns\n",
+    "    verbose=True,  # Useful for doing sanity checks on matching patterns\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "crested_dev",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.12.7"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}

From 256bb148dfd873998ffce5aaabc62165985cf9bd Mon Sep 17 00:00:00 2001
From: LukasMahieu <lukas.mahieu@kuleuven.be>
Date: Thu, 21 Nov 2024 13:58:18 +0100
Subject: [PATCH 4/9] test plots

---
 src/crested/pl/patterns/_modisco_results.py |    4 +-
 test_plotting.ipynb                         | 1759 +++----------------
 2 files changed, 228 insertions(+), 1535 deletions(-)

diff --git a/src/crested/pl/patterns/_modisco_results.py b/src/crested/pl/patterns/_modisco_results.py
index 0e4f91b8..8c849a2f 100644
--- a/src/crested/pl/patterns/_modisco_results.py
+++ b/src/crested/pl/patterns/_modisco_results.py
@@ -213,7 +213,7 @@ def clustermap(
     pattern_matrix
         2D NumPy array containing pattern data.
     classes
-        List of class labels, matching the rows of the pattern matrix.
+        List of all class labels, matching the rows of the pattern matrix.
     subset
         List of class labels to subset the matrix.
     figsize
@@ -267,8 +267,6 @@ def clustermap(
     column_indices = np.where(non_zero_columns)[0]
     data = pd.DataFrame(pattern_matrix, columns=column_indices)
 
-    data = pd.DataFrame(pattern_matrix)
-
     if pat_seqs is not None:
         plt.rc("text", usetex=False)  # Turn off LaTeX to speed up rendering
 
diff --git a/test_plotting.ipynb b/test_plotting.ipynb
index 458ed2cc..ca13c7fc 100644
--- a/test_plotting.ipynb
+++ b/test_plotting.ipynb
@@ -19,8 +19,8 @@
    "outputs": [],
    "source": [
     "# bigwigs, regions = crested.get_dataset(\"mouse_cortex_bigwig\")\n",
-    "bigwigs = \"/home/luna.kuleuven.be/u0166574/.cache/crested/data/mouse_biccn/bigwigs.tar.gz.untar\"\n",
-    "regions = \"/home/luna.kuleuven.be/u0166574/.cache/crested/data/mouse_biccn/consensus_peaks_biccn.bed\""
+    "bigwigs = \"/staging/leuven/stg_00002/lcb/lmahieu/data/biccn/mouse_cortex/bigwigs\"\n",
+    "regions = \"/staging/leuven/stg_00002/lcb/lmahieu/data/biccn/mouse_cortex/consensus_peaks_biccn.bed\""
    ]
   },
   {
@@ -455,7 +455,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 2,
+   "execution_count": 8,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -466,21 +466,20 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 18,
+   "execution_count": 9,
    "metadata": {},
    "outputs": [],
    "source": [
-    "anndata_path = (\n",
-    "    \"/home/luna.kuleuven.be/u0166574/Desktop/data/biccn/mouse_biccn_data_filtered.h5ad\"\n",
-    ")\n",
-    "model_path = \"/home/luna.kuleuven.be/u0166574/Desktop/data/biccn/BICCN_model.keras\"\n",
-    "genome_path = \"/home/luna.kuleuven.be/u0166574/.local/share/genomes/mm10/mm10.fa\"\n",
-    "bigwigs = \"/home/luna.kuleuven.be/u0166574/.cache/crested/data/mouse_biccn/bigwigs.tar.gz.untar\""
+    "bigwigs = \"/staging/leuven/stg_00002/lcb/lmahieu/data/biccn/mouse_cortex/bigwigs\"\n",
+    "regions = \"/staging/leuven/stg_00002/lcb/lmahieu/data/biccn/mouse_cortex/consensus_peaks_biccn.bed\"\n",
+    "anndata_path = \"/staging/leuven/stg_00002/lcb/nkemp/models/BICCN_model/mouse_biccn_data_filtered.h5ad\"\n",
+    "model_path = \"/staging/leuven/stg_00002/lcb/nkemp/models/BICCN_model/BICCN_model.keras\"\n",
+    "genome_path = \"/staging/leuven/stg_00002/lcb/lmahieu/data/genomes/mm10.fa\""
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 19,
+   "execution_count": 10,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -489,7 +488,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 20,
+   "execution_count": 11,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -500,29 +499,9 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 7,
+   "execution_count": 12,
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "2024-11-19T11:11:45.832406+0100 WARNING No GPUs available, falling back to CPU.\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "2024-11-19 11:11:45.830515: E external/local_xla/xla/stream_executor/cuda/cuda_driver.cc:152] failed call to cuInit: INTERNAL: CUDA error: Failed call to cuInit: CUDA_ERROR_NO_DEVICE: no CUDA-capable device is detected\n",
-      "2024-11-19 11:11:45.830535: I external/local_xla/xla/stream_executor/cuda/cuda_diagnostics.cc:137] retrieving CUDA diagnostic information for host: gbw-l-l0080\n",
-      "2024-11-19 11:11:45.830539: I external/local_xla/xla/stream_executor/cuda/cuda_diagnostics.cc:144] hostname: gbw-l-l0080\n",
-      "2024-11-19 11:11:45.830675: I external/local_xla/xla/stream_executor/cuda/cuda_diagnostics.cc:168] libcuda reported version is: 555.42.6\n",
-      "2024-11-19 11:11:45.830686: I external/local_xla/xla/stream_executor/cuda/cuda_diagnostics.cc:172] kernel reported version is: 555.42.6\n",
-      "2024-11-19 11:11:45.830688: I external/local_xla/xla/stream_executor/cuda/cuda_diagnostics.cc:259] kernel version seems to match DSO: 555.42.6\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "trainer = crested.tl.Crested(data=datamodule)\n",
     "trainer.load_model(model_path)"
@@ -532,7 +511,23 @@
    "cell_type": "code",
    "execution_count": 13,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/lustre1/project/stg_00002/mambaforge/vsc35862/envs/crested_dev_torch/lib/python3.12/site-packages/torch/_dynamo/variables/functions.py:710: UserWarning: Graph break for an optree C/C++ function optree._C.PyCapsule.flatten. Consider using torch.utils._pytree - https://github.com/pytorch/pytorch/blob/main/torch/utils/_pytree.py\n",
+      "  torch._dynamo.utils.warn_once(msg)\n",
+      "W1119 14:23:18.977000 2909941 site-packages/torch/_dynamo/convert_frame.py:844] [3/8] torch._dynamo hit config.cache_size_limit (8)\n",
+      "W1119 14:23:18.977000 2909941 site-packages/torch/_dynamo/convert_frame.py:844] [3/8]    function: '__call__' (/lustre1/project/stg_00002/mambaforge/vsc35862/envs/crested_dev_torch/lib/python3.12/site-packages/keras/src/layers/layer.py:777)\n",
+      "W1119 14:23:18.977000 2909941 site-packages/torch/_dynamo/convert_frame.py:844] [3/8]    last reason: 3/0: ___check_type_id(L['self'], 94824290790496)                 \n",
+      "W1119 14:23:18.977000 2909941 site-packages/torch/_dynamo/convert_frame.py:844] [3/8] To log all recompilation reasons, use TORCH_LOGS=\"recompiles\".\n",
+      "W1119 14:23:18.977000 2909941 site-packages/torch/_dynamo/convert_frame.py:844] [3/8] To diagnose recompilation issues, see https://pytorch.org/docs/main/torch.compiler_troubleshooting.html.\n",
+      "/lustre1/project/stg_00002/mambaforge/vsc35862/envs/crested_dev_torch/lib/python3.12/site-packages/torch/_dynamo/variables/functions.py:710: UserWarning: Graph break for an optree C/C++ function optree._C.PyCapsule.is_leaf. Consider using torch.utils._pytree - https://github.com/pytorch/pytorch/blob/main/torch/utils/_pytree.py\n",
+      "  torch._dynamo.utils.warn_once(msg)\n"
+     ]
+    }
+   ],
    "source": [
     "%matplotlib inline\n",
     "chrom = \"chr4\"\n",
@@ -603,7 +598,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 21,
+   "execution_count": 17,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -614,12 +609,12 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 22,
+   "execution_count": 19,
    "metadata": {},
    "outputs": [
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 3000x1000 with 2 Axes>"
       ]
@@ -644,14 +639,14 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 23,
+   "execution_count": 20,
    "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "2024-11-19T11:15:46.995714+0100 INFO After sorting and filtering, kept 19000 regions.\n"
+      "2024-11-19T14:23:53.784408+0100 INFO After sorting and filtering, kept 19000 regions.\n"
      ]
     }
    ],
@@ -661,7 +656,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 24,
+   "execution_count": 21,
    "metadata": {},
    "outputs": [
     {
@@ -673,7 +668,7 @@
        "      dtype='object')"
       ]
      },
-     "execution_count": 24,
+     "execution_count": 21,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -684,64 +679,117 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 26,
+   "execution_count": 23,
    "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "2024-11-19T11:16:06.469591+0100 INFO Found 'Class name' column in adata.var. Using specific regions per class to calculate contribution scores.\n",
-      "2024-11-19T11:16:06.498659+0100 INFO Calculating contribution scores for 1 class(es) and 1000 region(s).\n"
-     ]
-    },
-    {
-     "ename": "KeyboardInterrupt",
-     "evalue": "",
-     "output_type": "error",
-     "traceback": [
-      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
-      "\u001b[0;31mKeyboardInterrupt\u001b[0m                         Traceback (most recent call last)",
-      "\u001b[0;32m/tmp/ipykernel_45203/4071556197.py\u001b[0m in \u001b[0;36m?\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m trainer.tfmodisco_calculate_and_save_contribution_scores(\n\u001b[0m\u001b[1;32m      2\u001b[0m     \u001b[0madata\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      3\u001b[0m     \u001b[0moutput_dir\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m\"modisco_results\"\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      4\u001b[0m     \u001b[0mclass_names\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m\"Astro\"\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-      "\u001b[0;32m~/Desktop/projects/CREsted/src/crested/tl/_crested.py\u001b[0m in \u001b[0;36m?\u001b[0;34m(self, adata, output_dir, method, class_names)\u001b[0m\n\u001b[1;32m   1309\u001b[0m             \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1310\u001b[0m                 \u001b[0mclass_regions\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0madata\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mvar\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mindex\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtolist\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1311\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1312\u001b[0m             \u001b[0;31m# Calculate contribution scores for the regions of the current class\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1313\u001b[0;31m             contrib_scores, one_hot_seqs = self.calculate_contribution_scores_regions(\n\u001b[0m\u001b[1;32m   1314\u001b[0m                 \u001b[0mregion_idx\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mclass_regions\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1315\u001b[0m                 \u001b[0mclass_names\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mclass_name\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1316\u001b[0m                 \u001b[0mmethod\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mmethod\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-      "\u001b[0;32m~/Desktop/projects/CREsted/src/crested/tl/_crested.py\u001b[0m in \u001b[0;36m?\u001b[0;34m(self, region_idx, class_names, method, disable_tqdm)\u001b[0m\n\u001b[1;32m   1004\u001b[0m         \u001b[0;32mfor\u001b[0m \u001b[0mregion\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mregion_idx\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1005\u001b[0m             sequences.append(\n\u001b[1;32m   1006\u001b[0m                 \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0manndatamodule\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mpredict_dataset\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msequence_loader\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mget_sequence\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mregion\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1007\u001b[0m             \u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1008\u001b[0;31m         return self.calculate_contribution_scores_sequence(\n\u001b[0m\u001b[1;32m   1009\u001b[0m             \u001b[0msequences\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0msequences\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1010\u001b[0m             \u001b[0mclass_names\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mclass_names\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1011\u001b[0m             \u001b[0mmethod\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mmethod\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-      "\u001b[0;32m~/Desktop/projects/CREsted/src/crested/tl/_crested.py\u001b[0m in \u001b[0;36m?\u001b[0;34m(self, sequences, class_names, method, disable_tqdm)\u001b[0m\n\u001b[1;32m   1087\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1088\u001b[0m             \u001b[0;32mfor\u001b[0m \u001b[0mi\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mclass_index\u001b[0m \u001b[0;32min\u001b[0m \u001b[0menumerate\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mclass_indices\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1089\u001b[0m                 \u001b[0mexplainer\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mExplainer\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmodel\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mclass_index\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mclass_index\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1090\u001b[0m                 \u001b[0;32mif\u001b[0m \u001b[0mmethod\u001b[0m \u001b[0;34m==\u001b[0m \u001b[0;34m\"integrated_grad\"\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1091\u001b[0;31m                     scores[:, i, :, :] = explainer.integrated_grad(\n\u001b[0m\u001b[1;32m   1092\u001b[0m                         \u001b[0mx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mbaseline_type\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m\"zeros\"\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1093\u001b[0m                     \u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1094\u001b[0m                 \u001b[0;32melif\u001b[0m \u001b[0mmethod\u001b[0m \u001b[0;34m==\u001b[0m \u001b[0;34m\"mutagenesis\"\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-      "\u001b[0;32m~/Desktop/projects/CREsted/src/crested/tl/_explainer_tf.py\u001b[0m in \u001b[0;36m?\u001b[0;34m(self, X, baseline_type, num_steps)\u001b[0m\n\u001b[1;32m     49\u001b[0m         \u001b[0mscores\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     50\u001b[0m         \u001b[0;32mfor\u001b[0m \u001b[0mx\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mX\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     51\u001b[0m             \u001b[0mx\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mexpand_dims\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0maxis\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     52\u001b[0m             \u001b[0mbaseline\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mset_baseline\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mbaseline_type\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mnum_samples\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 53\u001b[0;31m             intgrad_scores = integrated_grad(\n\u001b[0m\u001b[1;32m     54\u001b[0m                 \u001b[0mx\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     55\u001b[0m                 \u001b[0mmodel\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmodel\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     56\u001b[0m                 \u001b[0mbaseline\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mbaseline\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-      "\u001b[0;32m~/Desktop/projects/CREsted/src/crested/tl/_explainer_tf.py\u001b[0m in \u001b[0;36m?\u001b[0;34m(x, model, baseline, num_steps, class_index, func)\u001b[0m\n\u001b[1;32m    165\u001b[0m         \u001b[0;32mreturn\u001b[0m \u001b[0mx\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    166\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    167\u001b[0m     \u001b[0msteps\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtf\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlinspace\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mstart\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m0.0\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mstop\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m1.0\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mnum\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mnum_steps\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0;36m1\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    168\u001b[0m     \u001b[0mx_interp\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0minterpolate_data\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mbaseline\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0msteps\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 169\u001b[0;31m     \u001b[0mgrad\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0msaliency_map\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx_interp\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmodel\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mclass_index\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mclass_index\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfunc\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mfunc\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    170\u001b[0m     \u001b[0mavg_grad\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mintegral_approximation\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mgrad\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    171\u001b[0m     \u001b[0mavg_grad\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mexpand_dims\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mavg_grad\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0maxis\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    172\u001b[0m     \u001b[0;32mreturn\u001b[0m \u001b[0mavg_grad\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-      "\u001b[0;32m~/Desktop/projects/CREsted/src/crested/tl/_explainer_tf.py\u001b[0m in \u001b[0;36m?\u001b[0;34m(X, model, class_index, func)\u001b[0m\n\u001b[1;32m    107\u001b[0m         \u001b[0;32mif\u001b[0m \u001b[0mclass_index\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    108\u001b[0m             \u001b[0moutputs\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmodel\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mX\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mclass_index\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    109\u001b[0m         \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    110\u001b[0m             \u001b[0moutputs\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mfunc\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mmodel\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mX\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 111\u001b[0;31m     \u001b[0;32mreturn\u001b[0m \u001b[0mtape\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mgradient\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0moutputs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mX\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
-      "\u001b[0;32m~/miniconda3/envs/crested_dev/lib/python3.12/site-packages/tensorflow/python/eager/backprop.py\u001b[0m in \u001b[0;36m?\u001b[0;34m(self, target, sources, output_gradients, unconnected_gradients)\u001b[0m\n\u001b[1;32m   1062\u001b[0m               \u001b[0moutput_gradients\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1063\u001b[0m       output_gradients = [None if x is None else ops.convert_to_tensor(x)\n\u001b[1;32m   1064\u001b[0m                           \u001b[0;32mfor\u001b[0m \u001b[0mx\u001b[0m \u001b[0;32min\u001b[0m \u001b[0moutput_gradients\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1065\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1066\u001b[0;31m     flat_grad = imperative_grad.imperative_grad(\n\u001b[0m\u001b[1;32m   1067\u001b[0m         \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_tape\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1068\u001b[0m         \u001b[0mflat_targets\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1069\u001b[0m         \u001b[0mflat_sources\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-      "\u001b[0;32m~/miniconda3/envs/crested_dev/lib/python3.12/site-packages/tensorflow/python/eager/imperative_grad.py\u001b[0m in \u001b[0;36m?\u001b[0;34m(tape, target, sources, output_gradients, sources_raw, unconnected_gradients)\u001b[0m\n\u001b[1;32m     63\u001b[0m   \u001b[0;32mexcept\u001b[0m \u001b[0mValueError\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     64\u001b[0m     raise ValueError(\n\u001b[1;32m     65\u001b[0m         \u001b[0;34m\"Unknown value for unconnected_gradients: %r\"\u001b[0m \u001b[0;34m%\u001b[0m \u001b[0munconnected_gradients\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     66\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 67\u001b[0;31m   return pywrap_tfe.TFE_Py_TapeGradient(\n\u001b[0m\u001b[1;32m     68\u001b[0m       \u001b[0mtape\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_tape\u001b[0m\u001b[0;34m,\u001b[0m  \u001b[0;31m# pylint: disable=protected-access\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     69\u001b[0m       \u001b[0mtarget\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     70\u001b[0m       \u001b[0msources\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-      "\u001b[0;32m~/miniconda3/envs/crested_dev/lib/python3.12/site-packages/tensorflow/python/eager/backprop.py\u001b[0m in \u001b[0;36m?\u001b[0;34m(op_name, attr_tuple, num_inputs, inputs, outputs, out_grads, skip_input_indices, forward_pass_name_scope)\u001b[0m\n\u001b[1;32m    144\u001b[0m     \u001b[0mgradient_name_scope\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m\"gradient_tape/\"\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    145\u001b[0m     \u001b[0;32mif\u001b[0m \u001b[0mforward_pass_name_scope\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    146\u001b[0m       \u001b[0mgradient_name_scope\u001b[0m \u001b[0;34m+=\u001b[0m \u001b[0mforward_pass_name_scope\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0;34m\"/\"\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    147\u001b[0m     \u001b[0;32mwith\u001b[0m \u001b[0mops\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mname_scope\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mgradient_name_scope\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 148\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mgrad_fn\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mmock_op\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0mout_grads\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    149\u001b[0m   \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    150\u001b[0m     \u001b[0;32mreturn\u001b[0m \u001b[0mgrad_fn\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mmock_op\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0mout_grads\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-      "\u001b[0;32m~/miniconda3/envs/crested_dev/lib/python3.12/site-packages/tensorflow/python/ops/nn_grad.py\u001b[0m in \u001b[0;36m?\u001b[0;34m(op, grad)\u001b[0m\n\u001b[1;32m    590\u001b[0m           \u001b[0mpadding\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mpadding\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    591\u001b[0m           \u001b[0mexplicit_paddings\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mexplicit_paddings\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    592\u001b[0m           \u001b[0muse_cudnn_on_gpu\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0muse_cudnn_on_gpu\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    593\u001b[0m           \u001b[0mdata_format\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mdata_format\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 594\u001b[0;31m       gen_nn_ops.conv2d_backprop_filter(\n\u001b[0m\u001b[1;32m    595\u001b[0m           \u001b[0mop\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0minputs\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    596\u001b[0m           \u001b[0mshape_1\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    597\u001b[0m           \u001b[0mgrad\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-      "\u001b[0;32m~/miniconda3/envs/crested_dev/lib/python3.12/site-packages/tensorflow/python/ops/gen_nn_ops.py\u001b[0m in \u001b[0;36m?\u001b[0;34m(input, filter_sizes, out_backprop, strides, padding, use_cudnn_on_gpu, explicit_paddings, data_format, dilations, name)\u001b[0m\n\u001b[1;32m   1495\u001b[0m         \u001b[0mdata_format\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m\"dilations\"\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdilations\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1496\u001b[0m       \u001b[0;32mreturn\u001b[0m \u001b[0m_result\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1497\u001b[0m     \u001b[0;32mexcept\u001b[0m \u001b[0m_core\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_NotOkStatusException\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0me\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1498\u001b[0m       \u001b[0m_ops\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mraise_from_not_ok_status\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0me\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mname\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1499\u001b[0;31m     \u001b[0;32mexcept\u001b[0m \u001b[0m_core\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_FallbackException\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1500\u001b[0m       \u001b[0;32mpass\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1501\u001b[0m     \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1502\u001b[0m       return conv2d_backprop_filter_eager_fallback(\n",
-      "\u001b[0;31mKeyboardInterrupt\u001b[0m: "
+      "2024-11-19T14:24:23.844262+0100 INFO Found 'Class name' column in adata.var. Using specific regions per class to calculate contribution scores.\n",
+      "2024-11-19T14:24:23.913092+0100 INFO Calculating contribution scores for 1 class(es) and 1000 region(s).\n",
+      "2024-11-19T14:25:25.889243+0100 INFO Calculating contribution scores for 1 class(es) and 1000 region(s).\n",
+      "2024-11-19T14:26:26.770164+0100 INFO Calculating contribution scores for 1 class(es) and 1000 region(s).\n",
+      "2024-11-19T14:27:29.048447+0100 INFO Calculating contribution scores for 1 class(es) and 1000 region(s).\n",
+      "2024-11-19T14:28:31.376441+0100 INFO Calculating contribution scores for 1 class(es) and 1000 region(s).\n",
+      "2024-11-19T14:29:33.783807+0100 INFO Calculating contribution scores for 1 class(es) and 1000 region(s).\n",
+      "2024-11-19T14:30:36.176708+0100 INFO Calculating contribution scores for 1 class(es) and 1000 region(s).\n",
+      "2024-11-19T14:31:38.554615+0100 INFO Calculating contribution scores for 1 class(es) and 1000 region(s).\n",
+      "2024-11-19T14:32:40.842670+0100 INFO Calculating contribution scores for 1 class(es) and 1000 region(s).\n",
+      "2024-11-19T14:33:42.983441+0100 INFO Calculating contribution scores for 1 class(es) and 1000 region(s).\n",
+      "2024-11-19T14:34:45.334532+0100 INFO Calculating contribution scores for 1 class(es) and 1000 region(s).\n",
+      "2024-11-19T14:35:47.709618+0100 INFO Calculating contribution scores for 1 class(es) and 1000 region(s).\n",
+      "2024-11-19T14:36:49.798309+0100 INFO Calculating contribution scores for 1 class(es) and 1000 region(s).\n",
+      "2024-11-19T14:37:51.918359+0100 INFO Calculating contribution scores for 1 class(es) and 1000 region(s).\n",
+      "2024-11-19T14:38:54.001517+0100 INFO Calculating contribution scores for 1 class(es) and 1000 region(s).\n",
+      "2024-11-19T14:39:56.071311+0100 INFO Calculating contribution scores for 1 class(es) and 1000 region(s).\n",
+      "2024-11-19T14:40:58.541120+0100 INFO Calculating contribution scores for 1 class(es) and 1000 region(s).\n",
+      "2024-11-19T14:42:00.745975+0100 INFO Calculating contribution scores for 1 class(es) and 1000 region(s).\n",
+      "2024-11-19T14:43:03.146057+0100 INFO Calculating contribution scores for 1 class(es) and 1000 region(s).\n",
+      "2024-11-19T14:44:05.160265+0100 INFO Contribution scores and one-hot encoded sequences saved to modisco_results\n"
      ]
     }
    ],
    "source": [
     "trainer.tfmodisco_calculate_and_save_contribution_scores(\n",
-    "    adata, output_dir=\"modisco_results\", class_names=[\"Astro\"], method=\"integrated_grad\"\n",
+    "    adata,\n",
+    "    output_dir=\"modisco_results\",\n",
+    "    class_names=list(adata.obs_names),\n",
+    "    method=\"integrated_grad\",\n",
     ")"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 35,
+   "execution_count": 24,
    "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "2024-11-19T10:27:37.279986+0100 INFO No class names provided, using all found in the contribution directory: ['Astro']\n",
-      "2024-11-19T10:27:37.350093+0100 INFO Running modisco for class: Astro\n",
-      "Using 245 positive seqlets\n"
+      "2024-11-19T14:45:38.812266+0100 INFO No class names provided, using all found in the contribution directory: ['Astro', 'Micro_PVM', 'L6IT', 'L2_3IT', 'Endo', 'L5ET', 'Oligo', 'OPC', 'L6CT', 'L5_6NP', 'VLMC', 'Pvalb', 'Sst', 'SstChodl', 'L5IT', 'L6b', 'Vip', 'Sncg', 'Lamp5']\n",
+      "Modisco results already exist for class: Astro\n",
+      "2024-11-19T14:45:39.694948+0100 INFO Running modisco for class: Micro_PVM\n",
+      "Using 5000 positive seqlets\n",
+      "Extracted 3953 negative seqlets\n",
+      "2024-11-19T14:54:24.312604+0100 INFO Running modisco for class: L6IT\n",
+      "Using 5000 positive seqlets\n",
+      "Extracted 1089 negative seqlets\n",
+      "2024-11-19T14:59:20.188632+0100 INFO Running modisco for class: L2_3IT\n",
+      "Using 5000 positive seqlets\n",
+      "Extracted 882 negative seqlets\n",
+      "2024-11-19T15:05:03.870196+0100 INFO Running modisco for class: Endo\n",
+      "Using 5000 positive seqlets\n",
+      "Extracted 2091 negative seqlets\n",
+      "2024-11-19T15:11:49.397714+0100 INFO Running modisco for class: L5ET\n",
+      "Using 4601 positive seqlets\n",
+      "Extracted 134 negative seqlets\n",
+      "2024-11-19T15:16:20.926111+0100 INFO Running modisco for class: Oligo\n",
+      "Using 5000 positive seqlets\n",
+      "Extracted 4861 negative seqlets\n",
+      "2024-11-19T15:24:48.550881+0100 INFO Running modisco for class: OPC\n",
+      "Using 5000 positive seqlets\n",
+      "Extracted 4857 negative seqlets\n",
+      "2024-11-19T15:34:38.003971+0100 INFO Running modisco for class: L6CT\n",
+      "Using 5000 positive seqlets\n",
+      "Extracted 783 negative seqlets\n",
+      "2024-11-19T15:39:55.766461+0100 INFO Running modisco for class: L5_6NP\n",
+      "Using 4860 positive seqlets\n",
+      "Extracted 958 negative seqlets\n",
+      "2024-11-19T15:45:49.600755+0100 INFO Running modisco for class: VLMC\n",
+      "Using 5000 positive seqlets\n",
+      "Extracted 2096 negative seqlets\n",
+      "2024-11-19T15:52:40.733338+0100 INFO Running modisco for class: Pvalb\n",
+      "Using 4916 positive seqlets\n",
+      "Extracted 753 negative seqlets\n",
+      "2024-11-19T15:58:12.321591+0100 INFO Running modisco for class: Sst\n",
+      "Using 5000 positive seqlets\n",
+      "Extracted 1040 negative seqlets\n",
+      "2024-11-19T16:04:48.703295+0100 INFO Running modisco for class: SstChodl\n",
+      "Using 5000 positive seqlets\n",
+      "Extracted 4910 negative seqlets\n",
+      "2024-11-19T16:15:37.942089+0100 INFO Running modisco for class: L5IT\n",
+      "Using 5000 positive seqlets\n",
+      "Extracted 855 negative seqlets\n",
+      "2024-11-19T16:21:38.185816+0100 INFO Running modisco for class: L6b\n",
+      "Using 5000 positive seqlets\n",
+      "Extracted 722 negative seqlets\n",
+      "2024-11-19T16:26:58.687186+0100 INFO Running modisco for class: Vip\n",
+      "Using 5000 positive seqlets\n",
+      "Extracted 1255 negative seqlets\n",
+      "2024-11-19T16:33:23.117233+0100 INFO Running modisco for class: Sncg\n",
+      "Using 5000 positive seqlets\n",
+      "Extracted 972 negative seqlets\n",
+      "2024-11-19T16:38:58.062928+0100 INFO Running modisco for class: Lamp5\n",
+      "Using 5000 positive seqlets\n",
+      "Extracted 878 negative seqlets\n"
      ]
     }
    ],
    "source": [
     "crested.tl.modisco.tfmodisco(\n",
-    "    window=100,\n",
+    "    window=1000,\n",
     "    output_dir=\"modisco_results\",\n",
     "    contrib_dir=\"modisco_results\",\n",
     "    report=False,\n",
@@ -750,28 +798,21 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 42,
+   "execution_count": 1,
    "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "2024-11-19T10:32:20.571699+0100 INFO Starting genomic contributions plot for classes: ['Astro']\n"
+      "2024-11-19T14:18:30.672153+0100 INFO Starting genomic contributions plot for classes: ['Astro']\n"
      ]
-    },
-    {
-     "data": {
-      "image/png": "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",
-      "text/plain": [
-       "<Figure size 600x800 with 4 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
     }
    ],
    "source": [
+    "%matplotlib inline\n",
+    "import crested\n",
+    "\n",
     "crested.pl.patterns.modisco_results(\n",
     "    classes=[\"Astro\"],\n",
     "    contribution=\"positive\",\n",
@@ -784,7 +825,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 5,
+   "execution_count": 2,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -796,7 +837,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 7,
+   "execution_count": 3,
    "metadata": {},
    "outputs": [
     {
@@ -804,1449 +845,20 @@
      "output_type": "stream",
      "text": [
       "Reading file modisco_results/Astro_modisco_results.h5\n",
-      "Warning: TOMTOM error while comparing patterns Astro_pos_patterns_1 and Astro_pos_patterns_0. Returning no match.\n",
-      "Error details: Failed in nopython mode pipeline (step: nopython frontend)\n",
-      "\u001b[1m\u001b[1m\u001b[1m\u001b[1mFailed in nopython mode pipeline (step: nopython frontend)\n",
-      "\u001b[1m\u001b[1mNo implementation of function Function(<built-in function iadd>) found for signature:\n",
-      " \n",
-      " >>> iadd(Literal[int](0), array(int32, 1d, C))\n",
-      " \n",
-      "There are 18 candidate implementations:\n",
-      "\u001b[1m     - Of which 16 did not match due to:\n",
-      "     Overload of function 'iadd': File: <numerous>: Line N/A.\n",
-      "       With argument(s): '(int64, array(int32, 1d, C))':\u001b[0m\n",
-      "\u001b[1m      No match.\u001b[0m\n",
-      "\u001b[1m     - Of which 2 did not match due to:\n",
-      "     Operator Overload in function 'iadd': File: unknown: Line unknown.\n",
-      "       With argument(s): '(int64, array(int32, 1d, C))':\u001b[0m\n",
-      "\u001b[1m      No match for registered cases:\n",
-      "       * (int64, int64) -> int64\n",
-      "       * (int64, uint64) -> int64\n",
-      "       * (uint64, int64) -> int64\n",
-      "       * (uint64, uint64) -> uint64\n",
-      "       * (float32, float32) -> float32\n",
-      "       * (float64, float64) -> float64\n",
-      "       * (complex64, complex64) -> complex64\n",
-      "       * (complex128, complex128) -> complex128\u001b[0m\n",
-      "\u001b[0m\n",
-      "\u001b[0m\u001b[1mDuring: typing of intrinsic-call at /home/luna.kuleuven.be/u0166574/miniconda3/envs/crested_dev_torch/lib/python3.12/site-packages/tangermeme/tools/tomtom.py (242)\u001b[0m\n",
-      "\u001b[1m\n",
-      "File \"../../../miniconda3/envs/crested_dev_torch/lib/python3.12/site-packages/tangermeme/tools/tomtom.py\", line 242:\u001b[0m\n",
-      "\u001b[1mdef _p_values(gamma, B_cdfs, rr_inv, T_lens, nq, offset, n_bins, results):\n",
-      "    <source elided>\n",
-      "\t\t\t\t\tj, t_idx = uint64(j), uint64(total_offset + j + k)\n",
-      "\u001b[1m\t\t\t\t\tscore += gamma[j, rr_inv[t_idx]]\n",
-      "\u001b[0m     \u001b[1m^\u001b[0m\u001b[0m\n",
-      "\n",
-      "\u001b[0m\u001b[1mDuring: resolving callee type: type(CPUDispatcher(<function _p_values at 0x709694269f80>))\u001b[0m\n",
-      "\u001b[0m\u001b[1mDuring: typing of call at /home/luna.kuleuven.be/u0166574/miniconda3/envs/crested_dev_torch/lib/python3.12/site-packages/tangermeme/tools/tomtom.py (341)\n",
-      "\u001b[0m\n",
-      "\u001b[0m\u001b[1mDuring: resolving callee type: type(CPUDispatcher(<function _p_values at 0x709694269f80>))\u001b[0m\n",
-      "\u001b[0m\u001b[1mDuring: typing of call at /home/luna.kuleuven.be/u0166574/miniconda3/envs/crested_dev_torch/lib/python3.12/site-packages/tangermeme/tools/tomtom.py (341)\n",
-      "\u001b[0m\n",
-      "\u001b[1m\n",
-      "File \"../../../miniconda3/envs/crested_dev_torch/lib/python3.12/site-packages/tangermeme/tools/tomtom.py\", line 341:\u001b[0m\n",
-      "\u001b[1mdef _tomtom(Q, T, Q_lens, T_lens, Q_norm, T_norm, rr_inv, rr_counts, n_nearest, \n",
-      "    <source elided>\n",
-      "\n",
-      "\u001b[1m\t\t_p_values(_gamma[pid], _B[pid], rr_inv, T_lens, nq, offset, \n",
-      "\u001b[0m  \u001b[1m^\u001b[0m\u001b[0m\n",
-      "\n",
-      "Warning: TOMTOM error while comparing patterns Astro_pos_patterns_2 and Astro_pos_patterns_0. Returning no match.\n",
-      "Error details: Failed in nopython mode pipeline (step: nopython frontend)\n",
-      "\u001b[1m\u001b[1m\u001b[1m\u001b[1mFailed in nopython mode pipeline (step: nopython frontend)\n",
-      "\u001b[1m\u001b[1mNo implementation of function Function(<built-in function iadd>) found for signature:\n",
-      " \n",
-      " >>> iadd(Literal[int](0), array(int32, 1d, C))\n",
-      " \n",
-      "There are 18 candidate implementations:\n",
-      "\u001b[1m     - Of which 16 did not match due to:\n",
-      "     Overload of function 'iadd': File: <numerous>: Line N/A.\n",
-      "       With argument(s): '(int64, array(int32, 1d, C))':\u001b[0m\n",
-      "\u001b[1m      No match.\u001b[0m\n",
-      "\u001b[1m     - Of which 2 did not match due to:\n",
-      "     Operator Overload in function 'iadd': File: unknown: Line unknown.\n",
-      "       With argument(s): '(int64, array(int32, 1d, C))':\u001b[0m\n",
-      "\u001b[1m      No match for registered cases:\n",
-      "       * (int64, int64) -> int64\n",
-      "       * (int64, uint64) -> int64\n",
-      "       * (uint64, int64) -> int64\n",
-      "       * (uint64, uint64) -> uint64\n",
-      "       * (float32, float32) -> float32\n",
-      "       * (float64, float64) -> float64\n",
-      "       * (complex64, complex64) -> complex64\n",
-      "       * (complex128, complex128) -> complex128\u001b[0m\n",
-      "\u001b[0m\n",
-      "\u001b[0m\u001b[1mDuring: typing of intrinsic-call at /home/luna.kuleuven.be/u0166574/miniconda3/envs/crested_dev_torch/lib/python3.12/site-packages/tangermeme/tools/tomtom.py (242)\u001b[0m\n",
-      "\u001b[1m\n",
-      "File \"../../../miniconda3/envs/crested_dev_torch/lib/python3.12/site-packages/tangermeme/tools/tomtom.py\", line 242:\u001b[0m\n",
-      "\u001b[1mdef _p_values(gamma, B_cdfs, rr_inv, T_lens, nq, offset, n_bins, results):\n",
-      "    <source elided>\n",
-      "\t\t\t\t\tj, t_idx = uint64(j), uint64(total_offset + j + k)\n",
-      "\u001b[1m\t\t\t\t\tscore += gamma[j, rr_inv[t_idx]]\n",
-      "\u001b[0m     \u001b[1m^\u001b[0m\u001b[0m\n",
-      "\n",
-      "\u001b[0m\u001b[1mDuring: resolving callee type: type(CPUDispatcher(<function _p_values at 0x709694269f80>))\u001b[0m\n",
-      "\u001b[0m\u001b[1mDuring: typing of call at /home/luna.kuleuven.be/u0166574/miniconda3/envs/crested_dev_torch/lib/python3.12/site-packages/tangermeme/tools/tomtom.py (341)\n",
-      "\u001b[0m\n",
-      "\u001b[0m\u001b[1mDuring: resolving callee type: type(CPUDispatcher(<function _p_values at 0x709694269f80>))\u001b[0m\n",
-      "\u001b[0m\u001b[1mDuring: typing of call at /home/luna.kuleuven.be/u0166574/miniconda3/envs/crested_dev_torch/lib/python3.12/site-packages/tangermeme/tools/tomtom.py (341)\n",
-      "\u001b[0m\n",
-      "\u001b[1m\n",
-      "File \"../../../miniconda3/envs/crested_dev_torch/lib/python3.12/site-packages/tangermeme/tools/tomtom.py\", line 341:\u001b[0m\n",
-      "\u001b[1mdef _tomtom(Q, T, Q_lens, T_lens, Q_norm, T_norm, rr_inv, rr_counts, n_nearest, \n",
-      "    <source elided>\n",
-      "\n",
-      "\u001b[1m\t\t_p_values(_gamma[pid], _B[pid], rr_inv, T_lens, nq, offset, \n",
-      "\u001b[0m  \u001b[1m^\u001b[0m\u001b[0m\n",
-      "\n",
-      "Warning: TOMTOM error while comparing patterns Astro_pos_patterns_2 and Astro_pos_patterns_1. Returning no match.\n",
-      "Error details: Failed in nopython mode pipeline (step: nopython frontend)\n",
-      "\u001b[1m\u001b[1m\u001b[1m\u001b[1mFailed in nopython mode pipeline (step: nopython frontend)\n",
-      "\u001b[1m\u001b[1mNo implementation of function Function(<built-in function iadd>) found for signature:\n",
-      " \n",
-      " >>> iadd(Literal[int](0), array(int32, 1d, C))\n",
-      " \n",
-      "There are 18 candidate implementations:\n",
-      "\u001b[1m     - Of which 16 did not match due to:\n",
-      "     Overload of function 'iadd': File: <numerous>: Line N/A.\n",
-      "       With argument(s): '(int64, array(int32, 1d, C))':\u001b[0m\n",
-      "\u001b[1m      No match.\u001b[0m\n",
-      "\u001b[1m     - Of which 2 did not match due to:\n",
-      "     Operator Overload in function 'iadd': File: unknown: Line unknown.\n",
-      "       With argument(s): '(int64, array(int32, 1d, C))':\u001b[0m\n",
-      "\u001b[1m      No match for registered cases:\n",
-      "       * (int64, int64) -> int64\n",
-      "       * (int64, uint64) -> int64\n",
-      "       * (uint64, int64) -> int64\n",
-      "       * (uint64, uint64) -> uint64\n",
-      "       * (float32, float32) -> float32\n",
-      "       * (float64, float64) -> float64\n",
-      "       * (complex64, complex64) -> complex64\n",
-      "       * (complex128, complex128) -> complex128\u001b[0m\n",
-      "\u001b[0m\n",
-      "\u001b[0m\u001b[1mDuring: typing of intrinsic-call at /home/luna.kuleuven.be/u0166574/miniconda3/envs/crested_dev_torch/lib/python3.12/site-packages/tangermeme/tools/tomtom.py (242)\u001b[0m\n",
-      "\u001b[1m\n",
-      "File \"../../../miniconda3/envs/crested_dev_torch/lib/python3.12/site-packages/tangermeme/tools/tomtom.py\", line 242:\u001b[0m\n",
-      "\u001b[1mdef _p_values(gamma, B_cdfs, rr_inv, T_lens, nq, offset, n_bins, results):\n",
-      "    <source elided>\n",
-      "\t\t\t\t\tj, t_idx = uint64(j), uint64(total_offset + j + k)\n",
-      "\u001b[1m\t\t\t\t\tscore += gamma[j, rr_inv[t_idx]]\n",
-      "\u001b[0m     \u001b[1m^\u001b[0m\u001b[0m\n",
-      "\n",
-      "\u001b[0m\u001b[1mDuring: resolving callee type: type(CPUDispatcher(<function _p_values at 0x709694269f80>))\u001b[0m\n",
-      "\u001b[0m\u001b[1mDuring: typing of call at /home/luna.kuleuven.be/u0166574/miniconda3/envs/crested_dev_torch/lib/python3.12/site-packages/tangermeme/tools/tomtom.py (341)\n",
-      "\u001b[0m\n",
-      "\u001b[0m\u001b[1mDuring: resolving callee type: type(CPUDispatcher(<function _p_values at 0x709694269f80>))\u001b[0m\n",
-      "\u001b[0m\u001b[1mDuring: typing of call at /home/luna.kuleuven.be/u0166574/miniconda3/envs/crested_dev_torch/lib/python3.12/site-packages/tangermeme/tools/tomtom.py (341)\n",
-      "\u001b[0m\n",
-      "\u001b[1m\n",
-      "File \"../../../miniconda3/envs/crested_dev_torch/lib/python3.12/site-packages/tangermeme/tools/tomtom.py\", line 341:\u001b[0m\n",
-      "\u001b[1mdef _tomtom(Q, T, Q_lens, T_lens, Q_norm, T_norm, rr_inv, rr_counts, n_nearest, \n",
-      "    <source elided>\n",
-      "\n",
-      "\u001b[1m\t\t_p_values(_gamma[pid], _B[pid], rr_inv, T_lens, nq, offset, \n",
-      "\u001b[0m  \u001b[1m^\u001b[0m\u001b[0m\n",
-      "\n",
-      "Warning: TOMTOM error while comparing patterns Astro_pos_patterns_3 and Astro_pos_patterns_0. Returning no match.\n",
-      "Error details: Failed in nopython mode pipeline (step: nopython frontend)\n",
-      "\u001b[1m\u001b[1m\u001b[1m\u001b[1mFailed in nopython mode pipeline (step: nopython frontend)\n",
-      "\u001b[1m\u001b[1mNo implementation of function Function(<built-in function iadd>) found for signature:\n",
-      " \n",
-      " >>> iadd(Literal[int](0), array(int32, 1d, C))\n",
-      " \n",
-      "There are 18 candidate implementations:\n",
-      "\u001b[1m     - Of which 16 did not match due to:\n",
-      "     Overload of function 'iadd': File: <numerous>: Line N/A.\n",
-      "       With argument(s): '(int64, array(int32, 1d, C))':\u001b[0m\n",
-      "\u001b[1m      No match.\u001b[0m\n",
-      "\u001b[1m     - Of which 2 did not match due to:\n",
-      "     Operator Overload in function 'iadd': File: unknown: Line unknown.\n",
-      "       With argument(s): '(int64, array(int32, 1d, C))':\u001b[0m\n",
-      "\u001b[1m      No match for registered cases:\n",
-      "       * (int64, int64) -> int64\n",
-      "       * (int64, uint64) -> int64\n",
-      "       * (uint64, int64) -> int64\n",
-      "       * (uint64, uint64) -> uint64\n",
-      "       * (float32, float32) -> float32\n",
-      "       * (float64, float64) -> float64\n",
-      "       * (complex64, complex64) -> complex64\n",
-      "       * (complex128, complex128) -> complex128\u001b[0m\n",
-      "\u001b[0m\n",
-      "\u001b[0m\u001b[1mDuring: typing of intrinsic-call at /home/luna.kuleuven.be/u0166574/miniconda3/envs/crested_dev_torch/lib/python3.12/site-packages/tangermeme/tools/tomtom.py (242)\u001b[0m\n",
-      "\u001b[1m\n",
-      "File \"../../../miniconda3/envs/crested_dev_torch/lib/python3.12/site-packages/tangermeme/tools/tomtom.py\", line 242:\u001b[0m\n",
-      "\u001b[1mdef _p_values(gamma, B_cdfs, rr_inv, T_lens, nq, offset, n_bins, results):\n",
-      "    <source elided>\n",
-      "\t\t\t\t\tj, t_idx = uint64(j), uint64(total_offset + j + k)\n",
-      "\u001b[1m\t\t\t\t\tscore += gamma[j, rr_inv[t_idx]]\n",
-      "\u001b[0m     \u001b[1m^\u001b[0m\u001b[0m\n",
-      "\n",
-      "\u001b[0m\u001b[1mDuring: resolving callee type: type(CPUDispatcher(<function _p_values at 0x709694269f80>))\u001b[0m\n",
-      "\u001b[0m\u001b[1mDuring: typing of call at /home/luna.kuleuven.be/u0166574/miniconda3/envs/crested_dev_torch/lib/python3.12/site-packages/tangermeme/tools/tomtom.py (341)\n",
-      "\u001b[0m\n",
-      "\u001b[0m\u001b[1mDuring: resolving callee type: type(CPUDispatcher(<function _p_values at 0x709694269f80>))\u001b[0m\n",
-      "\u001b[0m\u001b[1mDuring: typing of call at /home/luna.kuleuven.be/u0166574/miniconda3/envs/crested_dev_torch/lib/python3.12/site-packages/tangermeme/tools/tomtom.py (341)\n",
-      "\u001b[0m\n",
-      "\u001b[1m\n",
-      "File \"../../../miniconda3/envs/crested_dev_torch/lib/python3.12/site-packages/tangermeme/tools/tomtom.py\", line 341:\u001b[0m\n",
-      "\u001b[1mdef _tomtom(Q, T, Q_lens, T_lens, Q_norm, T_norm, rr_inv, rr_counts, n_nearest, \n",
-      "    <source elided>\n",
-      "\n",
-      "\u001b[1m\t\t_p_values(_gamma[pid], _B[pid], rr_inv, T_lens, nq, offset, \n",
-      "\u001b[0m  \u001b[1m^\u001b[0m\u001b[0m\n",
-      "\n",
-      "Warning: TOMTOM error while comparing patterns Astro_pos_patterns_3 and Astro_pos_patterns_1. Returning no match.\n",
-      "Error details: Failed in nopython mode pipeline (step: nopython frontend)\n",
-      "\u001b[1m\u001b[1m\u001b[1m\u001b[1mFailed in nopython mode pipeline (step: nopython frontend)\n",
-      "\u001b[1m\u001b[1mNo implementation of function Function(<built-in function iadd>) found for signature:\n",
-      " \n",
-      " >>> iadd(Literal[int](0), array(int32, 1d, C))\n",
-      " \n",
-      "There are 18 candidate implementations:\n",
-      "\u001b[1m     - Of which 16 did not match due to:\n",
-      "     Overload of function 'iadd': File: <numerous>: Line N/A.\n",
-      "       With argument(s): '(int64, array(int32, 1d, C))':\u001b[0m\n",
-      "\u001b[1m      No match.\u001b[0m\n",
-      "\u001b[1m     - Of which 2 did not match due to:\n",
-      "     Operator Overload in function 'iadd': File: unknown: Line unknown.\n",
-      "       With argument(s): '(int64, array(int32, 1d, C))':\u001b[0m\n",
-      "\u001b[1m      No match for registered cases:\n",
-      "       * (int64, int64) -> int64\n",
-      "       * (int64, uint64) -> int64\n",
-      "       * (uint64, int64) -> int64\n",
-      "       * (uint64, uint64) -> uint64\n",
-      "       * (float32, float32) -> float32\n",
-      "       * (float64, float64) -> float64\n",
-      "       * (complex64, complex64) -> complex64\n",
-      "       * (complex128, complex128) -> complex128\u001b[0m\n",
-      "\u001b[0m\n",
-      "\u001b[0m\u001b[1mDuring: typing of intrinsic-call at /home/luna.kuleuven.be/u0166574/miniconda3/envs/crested_dev_torch/lib/python3.12/site-packages/tangermeme/tools/tomtom.py (242)\u001b[0m\n",
-      "\u001b[1m\n",
-      "File \"../../../miniconda3/envs/crested_dev_torch/lib/python3.12/site-packages/tangermeme/tools/tomtom.py\", line 242:\u001b[0m\n",
-      "\u001b[1mdef _p_values(gamma, B_cdfs, rr_inv, T_lens, nq, offset, n_bins, results):\n",
-      "    <source elided>\n",
-      "\t\t\t\t\tj, t_idx = uint64(j), uint64(total_offset + j + k)\n",
-      "\u001b[1m\t\t\t\t\tscore += gamma[j, rr_inv[t_idx]]\n",
-      "\u001b[0m     \u001b[1m^\u001b[0m\u001b[0m\n",
-      "\n",
-      "\u001b[0m\u001b[1mDuring: resolving callee type: type(CPUDispatcher(<function _p_values at 0x709694269f80>))\u001b[0m\n",
-      "\u001b[0m\u001b[1mDuring: typing of call at /home/luna.kuleuven.be/u0166574/miniconda3/envs/crested_dev_torch/lib/python3.12/site-packages/tangermeme/tools/tomtom.py (341)\n",
-      "\u001b[0m\n",
-      "\u001b[0m\u001b[1mDuring: resolving callee type: type(CPUDispatcher(<function _p_values at 0x709694269f80>))\u001b[0m\n",
-      "\u001b[0m\u001b[1mDuring: typing of call at /home/luna.kuleuven.be/u0166574/miniconda3/envs/crested_dev_torch/lib/python3.12/site-packages/tangermeme/tools/tomtom.py (341)\n",
-      "\u001b[0m\n",
-      "\u001b[1m\n",
-      "File \"../../../miniconda3/envs/crested_dev_torch/lib/python3.12/site-packages/tangermeme/tools/tomtom.py\", line 341:\u001b[0m\n",
-      "\u001b[1mdef _tomtom(Q, T, Q_lens, T_lens, Q_norm, T_norm, rr_inv, rr_counts, n_nearest, \n",
-      "    <source elided>\n",
-      "\n",
-      "\u001b[1m\t\t_p_values(_gamma[pid], _B[pid], rr_inv, T_lens, nq, offset, \n",
-      "\u001b[0m  \u001b[1m^\u001b[0m\u001b[0m\n",
-      "\n",
-      "Warning: TOMTOM error while comparing patterns Astro_pos_patterns_3 and Astro_pos_patterns_2. Returning no match.\n",
-      "Error details: Failed in nopython mode pipeline (step: nopython frontend)\n",
-      "\u001b[1m\u001b[1m\u001b[1m\u001b[1mFailed in nopython mode pipeline (step: nopython frontend)\n",
-      "\u001b[1m\u001b[1mNo implementation of function Function(<built-in function iadd>) found for signature:\n",
-      " \n",
-      " >>> iadd(Literal[int](0), array(int32, 1d, C))\n",
-      " \n",
-      "There are 18 candidate implementations:\n",
-      "\u001b[1m     - Of which 16 did not match due to:\n",
-      "     Overload of function 'iadd': File: <numerous>: Line N/A.\n",
-      "       With argument(s): '(int64, array(int32, 1d, C))':\u001b[0m\n",
-      "\u001b[1m      No match.\u001b[0m\n",
-      "\u001b[1m     - Of which 2 did not match due to:\n",
-      "     Operator Overload in function 'iadd': File: unknown: Line unknown.\n",
-      "       With argument(s): '(int64, array(int32, 1d, C))':\u001b[0m\n",
-      "\u001b[1m      No match for registered cases:\n",
-      "       * (int64, int64) -> int64\n",
-      "       * (int64, uint64) -> int64\n",
-      "       * (uint64, int64) -> int64\n",
-      "       * (uint64, uint64) -> uint64\n",
-      "       * (float32, float32) -> float32\n",
-      "       * (float64, float64) -> float64\n",
-      "       * (complex64, complex64) -> complex64\n",
-      "       * (complex128, complex128) -> complex128\u001b[0m\n",
-      "\u001b[0m\n",
-      "\u001b[0m\u001b[1mDuring: typing of intrinsic-call at /home/luna.kuleuven.be/u0166574/miniconda3/envs/crested_dev_torch/lib/python3.12/site-packages/tangermeme/tools/tomtom.py (242)\u001b[0m\n",
-      "\u001b[1m\n",
-      "File \"../../../miniconda3/envs/crested_dev_torch/lib/python3.12/site-packages/tangermeme/tools/tomtom.py\", line 242:\u001b[0m\n",
-      "\u001b[1mdef _p_values(gamma, B_cdfs, rr_inv, T_lens, nq, offset, n_bins, results):\n",
-      "    <source elided>\n",
-      "\t\t\t\t\tj, t_idx = uint64(j), uint64(total_offset + j + k)\n",
-      "\u001b[1m\t\t\t\t\tscore += gamma[j, rr_inv[t_idx]]\n",
-      "\u001b[0m     \u001b[1m^\u001b[0m\u001b[0m\n",
-      "\n",
-      "\u001b[0m\u001b[1mDuring: resolving callee type: type(CPUDispatcher(<function _p_values at 0x709694269f80>))\u001b[0m\n",
-      "\u001b[0m\u001b[1mDuring: typing of call at /home/luna.kuleuven.be/u0166574/miniconda3/envs/crested_dev_torch/lib/python3.12/site-packages/tangermeme/tools/tomtom.py (341)\n",
-      "\u001b[0m\n",
-      "\u001b[0m\u001b[1mDuring: resolving callee type: type(CPUDispatcher(<function _p_values at 0x709694269f80>))\u001b[0m\n",
-      "\u001b[0m\u001b[1mDuring: typing of call at /home/luna.kuleuven.be/u0166574/miniconda3/envs/crested_dev_torch/lib/python3.12/site-packages/tangermeme/tools/tomtom.py (341)\n",
-      "\u001b[0m\n",
-      "\u001b[1m\n",
-      "File \"../../../miniconda3/envs/crested_dev_torch/lib/python3.12/site-packages/tangermeme/tools/tomtom.py\", line 341:\u001b[0m\n",
-      "\u001b[1mdef _tomtom(Q, T, Q_lens, T_lens, Q_norm, T_norm, rr_inv, rr_counts, n_nearest, \n",
-      "    <source elided>\n",
-      "\n",
-      "\u001b[1m\t\t_p_values(_gamma[pid], _B[pid], rr_inv, T_lens, nq, offset, \n",
-      "\u001b[0m  \u001b[1m^\u001b[0m\u001b[0m\n",
-      "\n",
-      "Warning: TOMTOM error while comparing patterns Astro_pos_patterns_0 and Astro_pos_patterns_1. Returning no match.\n",
-      "Error details: Failed in nopython mode pipeline (step: nopython frontend)\n",
-      "\u001b[1m\u001b[1m\u001b[1m\u001b[1mFailed in nopython mode pipeline (step: nopython frontend)\n",
-      "\u001b[1m\u001b[1mNo implementation of function Function(<built-in function iadd>) found for signature:\n",
-      " \n",
-      " >>> iadd(Literal[int](0), array(int32, 1d, C))\n",
-      " \n",
-      "There are 18 candidate implementations:\n",
-      "\u001b[1m     - Of which 16 did not match due to:\n",
-      "     Overload of function 'iadd': File: <numerous>: Line N/A.\n",
-      "       With argument(s): '(int64, array(int32, 1d, C))':\u001b[0m\n",
-      "\u001b[1m      No match.\u001b[0m\n",
-      "\u001b[1m     - Of which 2 did not match due to:\n",
-      "     Operator Overload in function 'iadd': File: unknown: Line unknown.\n",
-      "       With argument(s): '(int64, array(int32, 1d, C))':\u001b[0m\n",
-      "\u001b[1m      No match for registered cases:\n",
-      "       * (int64, int64) -> int64\n",
-      "       * (int64, uint64) -> int64\n",
-      "       * (uint64, int64) -> int64\n",
-      "       * (uint64, uint64) -> uint64\n",
-      "       * (float32, float32) -> float32\n",
-      "       * (float64, float64) -> float64\n",
-      "       * (complex64, complex64) -> complex64\n",
-      "       * (complex128, complex128) -> complex128\u001b[0m\n",
-      "\u001b[0m\n",
-      "\u001b[0m\u001b[1mDuring: typing of intrinsic-call at /home/luna.kuleuven.be/u0166574/miniconda3/envs/crested_dev_torch/lib/python3.12/site-packages/tangermeme/tools/tomtom.py (242)\u001b[0m\n",
-      "\u001b[1m\n",
-      "File \"../../../miniconda3/envs/crested_dev_torch/lib/python3.12/site-packages/tangermeme/tools/tomtom.py\", line 242:\u001b[0m\n",
-      "\u001b[1mdef _p_values(gamma, B_cdfs, rr_inv, T_lens, nq, offset, n_bins, results):\n",
-      "    <source elided>\n",
-      "\t\t\t\t\tj, t_idx = uint64(j), uint64(total_offset + j + k)\n",
-      "\u001b[1m\t\t\t\t\tscore += gamma[j, rr_inv[t_idx]]\n",
-      "\u001b[0m     \u001b[1m^\u001b[0m\u001b[0m\n",
-      "\n",
-      "\u001b[0m\u001b[1mDuring: resolving callee type: type(CPUDispatcher(<function _p_values at 0x709694269f80>))\u001b[0m\n",
-      "\u001b[0m\u001b[1mDuring: typing of call at /home/luna.kuleuven.be/u0166574/miniconda3/envs/crested_dev_torch/lib/python3.12/site-packages/tangermeme/tools/tomtom.py (341)\n",
-      "\u001b[0m\n",
-      "\u001b[0m\u001b[1mDuring: resolving callee type: type(CPUDispatcher(<function _p_values at 0x709694269f80>))\u001b[0m\n",
-      "\u001b[0m\u001b[1mDuring: typing of call at /home/luna.kuleuven.be/u0166574/miniconda3/envs/crested_dev_torch/lib/python3.12/site-packages/tangermeme/tools/tomtom.py (341)\n",
-      "\u001b[0m\n",
-      "\u001b[1m\n",
-      "File \"../../../miniconda3/envs/crested_dev_torch/lib/python3.12/site-packages/tangermeme/tools/tomtom.py\", line 341:\u001b[0m\n",
-      "\u001b[1mdef _tomtom(Q, T, Q_lens, T_lens, Q_norm, T_norm, rr_inv, rr_counts, n_nearest, \n",
-      "    <source elided>\n",
-      "\n",
-      "\u001b[1m\t\t_p_values(_gamma[pid], _B[pid], rr_inv, T_lens, nq, offset, \n",
-      "\u001b[0m  \u001b[1m^\u001b[0m\u001b[0m\n",
-      "\n",
-      "Warning: TOMTOM error while comparing patterns Astro_pos_patterns_1 and Astro_pos_patterns_0. Returning no match.\n",
-      "Error details: Failed in nopython mode pipeline (step: nopython frontend)\n",
-      "\u001b[1m\u001b[1m\u001b[1m\u001b[1mFailed in nopython mode pipeline (step: nopython frontend)\n",
-      "\u001b[1m\u001b[1mNo implementation of function Function(<built-in function iadd>) found for signature:\n",
-      " \n",
-      " >>> iadd(Literal[int](0), array(int32, 1d, C))\n",
-      " \n",
-      "There are 18 candidate implementations:\n",
-      "\u001b[1m     - Of which 16 did not match due to:\n",
-      "     Overload of function 'iadd': File: <numerous>: Line N/A.\n",
-      "       With argument(s): '(int64, array(int32, 1d, C))':\u001b[0m\n",
-      "\u001b[1m      No match.\u001b[0m\n",
-      "\u001b[1m     - Of which 2 did not match due to:\n",
-      "     Operator Overload in function 'iadd': File: unknown: Line unknown.\n",
-      "       With argument(s): '(int64, array(int32, 1d, C))':\u001b[0m\n",
-      "\u001b[1m      No match for registered cases:\n",
-      "       * (int64, int64) -> int64\n",
-      "       * (int64, uint64) -> int64\n",
-      "       * (uint64, int64) -> int64\n",
-      "       * (uint64, uint64) -> uint64\n",
-      "       * (float32, float32) -> float32\n",
-      "       * (float64, float64) -> float64\n",
-      "       * (complex64, complex64) -> complex64\n",
-      "       * (complex128, complex128) -> complex128\u001b[0m\n",
-      "\u001b[0m\n",
-      "\u001b[0m\u001b[1mDuring: typing of intrinsic-call at /home/luna.kuleuven.be/u0166574/miniconda3/envs/crested_dev_torch/lib/python3.12/site-packages/tangermeme/tools/tomtom.py (242)\u001b[0m\n",
-      "\u001b[1m\n",
-      "File \"../../../miniconda3/envs/crested_dev_torch/lib/python3.12/site-packages/tangermeme/tools/tomtom.py\", line 242:\u001b[0m\n",
-      "\u001b[1mdef _p_values(gamma, B_cdfs, rr_inv, T_lens, nq, offset, n_bins, results):\n",
-      "    <source elided>\n",
-      "\t\t\t\t\tj, t_idx = uint64(j), uint64(total_offset + j + k)\n",
-      "\u001b[1m\t\t\t\t\tscore += gamma[j, rr_inv[t_idx]]\n",
-      "\u001b[0m     \u001b[1m^\u001b[0m\u001b[0m\n",
-      "\n",
-      "\u001b[0m\u001b[1mDuring: resolving callee type: type(CPUDispatcher(<function _p_values at 0x709694269f80>))\u001b[0m\n",
-      "\u001b[0m\u001b[1mDuring: typing of call at /home/luna.kuleuven.be/u0166574/miniconda3/envs/crested_dev_torch/lib/python3.12/site-packages/tangermeme/tools/tomtom.py (341)\n",
-      "\u001b[0m\n",
-      "\u001b[0m\u001b[1mDuring: resolving callee type: type(CPUDispatcher(<function _p_values at 0x709694269f80>))\u001b[0m\n",
-      "\u001b[0m\u001b[1mDuring: typing of call at /home/luna.kuleuven.be/u0166574/miniconda3/envs/crested_dev_torch/lib/python3.12/site-packages/tangermeme/tools/tomtom.py (341)\n",
-      "\u001b[0m\n",
-      "\u001b[1m\n",
-      "File \"../../../miniconda3/envs/crested_dev_torch/lib/python3.12/site-packages/tangermeme/tools/tomtom.py\", line 341:\u001b[0m\n",
-      "\u001b[1mdef _tomtom(Q, T, Q_lens, T_lens, Q_norm, T_norm, rr_inv, rr_counts, n_nearest, \n",
-      "    <source elided>\n",
-      "\n",
-      "\u001b[1m\t\t_p_values(_gamma[pid], _B[pid], rr_inv, T_lens, nq, offset, \n",
-      "\u001b[0m  \u001b[1m^\u001b[0m\u001b[0m\n",
-      "\n",
-      "Warning: TOMTOM error while comparing patterns Astro_pos_patterns_0 and Astro_pos_patterns_2. Returning no match.\n",
-      "Error details: Failed in nopython mode pipeline (step: nopython frontend)\n",
-      "\u001b[1m\u001b[1m\u001b[1m\u001b[1mFailed in nopython mode pipeline (step: nopython frontend)\n",
-      "\u001b[1m\u001b[1mNo implementation of function Function(<built-in function iadd>) found for signature:\n",
-      " \n",
-      " >>> iadd(Literal[int](0), array(int32, 1d, C))\n",
-      " \n",
-      "There are 18 candidate implementations:\n",
-      "\u001b[1m     - Of which 16 did not match due to:\n",
-      "     Overload of function 'iadd': File: <numerous>: Line N/A.\n",
-      "       With argument(s): '(int64, array(int32, 1d, C))':\u001b[0m\n",
-      "\u001b[1m      No match.\u001b[0m\n",
-      "\u001b[1m     - Of which 2 did not match due to:\n",
-      "     Operator Overload in function 'iadd': File: unknown: Line unknown.\n",
-      "       With argument(s): '(int64, array(int32, 1d, C))':\u001b[0m\n",
-      "\u001b[1m      No match for registered cases:\n",
-      "       * (int64, int64) -> int64\n",
-      "       * (int64, uint64) -> int64\n",
-      "       * (uint64, int64) -> int64\n",
-      "       * (uint64, uint64) -> uint64\n",
-      "       * (float32, float32) -> float32\n",
-      "       * (float64, float64) -> float64\n",
-      "       * (complex64, complex64) -> complex64\n",
-      "       * (complex128, complex128) -> complex128\u001b[0m\n",
-      "\u001b[0m\n",
-      "\u001b[0m\u001b[1mDuring: typing of intrinsic-call at /home/luna.kuleuven.be/u0166574/miniconda3/envs/crested_dev_torch/lib/python3.12/site-packages/tangermeme/tools/tomtom.py (242)\u001b[0m\n",
-      "\u001b[1m\n",
-      "File \"../../../miniconda3/envs/crested_dev_torch/lib/python3.12/site-packages/tangermeme/tools/tomtom.py\", line 242:\u001b[0m\n",
-      "\u001b[1mdef _p_values(gamma, B_cdfs, rr_inv, T_lens, nq, offset, n_bins, results):\n",
-      "    <source elided>\n",
-      "\t\t\t\t\tj, t_idx = uint64(j), uint64(total_offset + j + k)\n",
-      "\u001b[1m\t\t\t\t\tscore += gamma[j, rr_inv[t_idx]]\n",
-      "\u001b[0m     \u001b[1m^\u001b[0m\u001b[0m\n",
-      "\n",
-      "\u001b[0m\u001b[1mDuring: resolving callee type: type(CPUDispatcher(<function _p_values at 0x709694269f80>))\u001b[0m\n",
-      "\u001b[0m\u001b[1mDuring: typing of call at /home/luna.kuleuven.be/u0166574/miniconda3/envs/crested_dev_torch/lib/python3.12/site-packages/tangermeme/tools/tomtom.py (341)\n",
-      "\u001b[0m\n",
-      "\u001b[0m\u001b[1mDuring: resolving callee type: type(CPUDispatcher(<function _p_values at 0x709694269f80>))\u001b[0m\n",
-      "\u001b[0m\u001b[1mDuring: typing of call at /home/luna.kuleuven.be/u0166574/miniconda3/envs/crested_dev_torch/lib/python3.12/site-packages/tangermeme/tools/tomtom.py (341)\n",
-      "\u001b[0m\n",
-      "\u001b[1m\n",
-      "File \"../../../miniconda3/envs/crested_dev_torch/lib/python3.12/site-packages/tangermeme/tools/tomtom.py\", line 341:\u001b[0m\n",
-      "\u001b[1mdef _tomtom(Q, T, Q_lens, T_lens, Q_norm, T_norm, rr_inv, rr_counts, n_nearest, \n",
-      "    <source elided>\n",
-      "\n",
-      "\u001b[1m\t\t_p_values(_gamma[pid], _B[pid], rr_inv, T_lens, nq, offset, \n",
-      "\u001b[0m  \u001b[1m^\u001b[0m\u001b[0m\n",
-      "\n",
-      "Warning: TOMTOM error while comparing patterns Astro_pos_patterns_2 and Astro_pos_patterns_0. Returning no match.\n",
-      "Error details: Failed in nopython mode pipeline (step: nopython frontend)\n",
-      "\u001b[1m\u001b[1m\u001b[1m\u001b[1mFailed in nopython mode pipeline (step: nopython frontend)\n",
-      "\u001b[1m\u001b[1mNo implementation of function Function(<built-in function iadd>) found for signature:\n",
-      " \n",
-      " >>> iadd(Literal[int](0), array(int32, 1d, C))\n",
-      " \n",
-      "There are 18 candidate implementations:\n",
-      "\u001b[1m     - Of which 16 did not match due to:\n",
-      "     Overload of function 'iadd': File: <numerous>: Line N/A.\n",
-      "       With argument(s): '(int64, array(int32, 1d, C))':\u001b[0m\n",
-      "\u001b[1m      No match.\u001b[0m\n",
-      "\u001b[1m     - Of which 2 did not match due to:\n",
-      "     Operator Overload in function 'iadd': File: unknown: Line unknown.\n",
-      "       With argument(s): '(int64, array(int32, 1d, C))':\u001b[0m\n",
-      "\u001b[1m      No match for registered cases:\n",
-      "       * (int64, int64) -> int64\n",
-      "       * (int64, uint64) -> int64\n",
-      "       * (uint64, int64) -> int64\n",
-      "       * (uint64, uint64) -> uint64\n",
-      "       * (float32, float32) -> float32\n",
-      "       * (float64, float64) -> float64\n",
-      "       * (complex64, complex64) -> complex64\n",
-      "       * (complex128, complex128) -> complex128\u001b[0m\n",
-      "\u001b[0m\n",
-      "\u001b[0m\u001b[1mDuring: typing of intrinsic-call at /home/luna.kuleuven.be/u0166574/miniconda3/envs/crested_dev_torch/lib/python3.12/site-packages/tangermeme/tools/tomtom.py (242)\u001b[0m\n",
-      "\u001b[1m\n",
-      "File \"../../../miniconda3/envs/crested_dev_torch/lib/python3.12/site-packages/tangermeme/tools/tomtom.py\", line 242:\u001b[0m\n",
-      "\u001b[1mdef _p_values(gamma, B_cdfs, rr_inv, T_lens, nq, offset, n_bins, results):\n",
-      "    <source elided>\n",
-      "\t\t\t\t\tj, t_idx = uint64(j), uint64(total_offset + j + k)\n",
-      "\u001b[1m\t\t\t\t\tscore += gamma[j, rr_inv[t_idx]]\n",
-      "\u001b[0m     \u001b[1m^\u001b[0m\u001b[0m\n",
-      "\n",
-      "\u001b[0m\u001b[1mDuring: resolving callee type: type(CPUDispatcher(<function _p_values at 0x709694269f80>))\u001b[0m\n",
-      "\u001b[0m\u001b[1mDuring: typing of call at /home/luna.kuleuven.be/u0166574/miniconda3/envs/crested_dev_torch/lib/python3.12/site-packages/tangermeme/tools/tomtom.py (341)\n",
-      "\u001b[0m\n",
-      "\u001b[0m\u001b[1mDuring: resolving callee type: type(CPUDispatcher(<function _p_values at 0x709694269f80>))\u001b[0m\n",
-      "\u001b[0m\u001b[1mDuring: typing of call at /home/luna.kuleuven.be/u0166574/miniconda3/envs/crested_dev_torch/lib/python3.12/site-packages/tangermeme/tools/tomtom.py (341)\n",
-      "\u001b[0m\n",
-      "\u001b[1m\n",
-      "File \"../../../miniconda3/envs/crested_dev_torch/lib/python3.12/site-packages/tangermeme/tools/tomtom.py\", line 341:\u001b[0m\n",
-      "\u001b[1mdef _tomtom(Q, T, Q_lens, T_lens, Q_norm, T_norm, rr_inv, rr_counts, n_nearest, \n",
-      "    <source elided>\n",
-      "\n",
-      "\u001b[1m\t\t_p_values(_gamma[pid], _B[pid], rr_inv, T_lens, nq, offset, \n",
-      "\u001b[0m  \u001b[1m^\u001b[0m\u001b[0m\n",
-      "\n",
-      "Warning: TOMTOM error while comparing patterns Astro_pos_patterns_0 and Astro_pos_patterns_3. Returning no match.\n",
-      "Error details: Failed in nopython mode pipeline (step: nopython frontend)\n",
-      "\u001b[1m\u001b[1m\u001b[1m\u001b[1mFailed in nopython mode pipeline (step: nopython frontend)\n",
-      "\u001b[1m\u001b[1mNo implementation of function Function(<built-in function iadd>) found for signature:\n",
-      " \n",
-      " >>> iadd(Literal[int](0), array(int32, 1d, C))\n",
-      " \n",
-      "There are 18 candidate implementations:\n",
-      "\u001b[1m     - Of which 16 did not match due to:\n",
-      "     Overload of function 'iadd': File: <numerous>: Line N/A.\n",
-      "       With argument(s): '(int64, array(int32, 1d, C))':\u001b[0m\n",
-      "\u001b[1m      No match.\u001b[0m\n",
-      "\u001b[1m     - Of which 2 did not match due to:\n",
-      "     Operator Overload in function 'iadd': File: unknown: Line unknown.\n",
-      "       With argument(s): '(int64, array(int32, 1d, C))':\u001b[0m\n",
-      "\u001b[1m      No match for registered cases:\n",
-      "       * (int64, int64) -> int64\n",
-      "       * (int64, uint64) -> int64\n",
-      "       * (uint64, int64) -> int64\n",
-      "       * (uint64, uint64) -> uint64\n",
-      "       * (float32, float32) -> float32\n",
-      "       * (float64, float64) -> float64\n",
-      "       * (complex64, complex64) -> complex64\n",
-      "       * (complex128, complex128) -> complex128\u001b[0m\n",
-      "\u001b[0m\n",
-      "\u001b[0m\u001b[1mDuring: typing of intrinsic-call at /home/luna.kuleuven.be/u0166574/miniconda3/envs/crested_dev_torch/lib/python3.12/site-packages/tangermeme/tools/tomtom.py (242)\u001b[0m\n",
-      "\u001b[1m\n",
-      "File \"../../../miniconda3/envs/crested_dev_torch/lib/python3.12/site-packages/tangermeme/tools/tomtom.py\", line 242:\u001b[0m\n",
-      "\u001b[1mdef _p_values(gamma, B_cdfs, rr_inv, T_lens, nq, offset, n_bins, results):\n",
-      "    <source elided>\n",
-      "\t\t\t\t\tj, t_idx = uint64(j), uint64(total_offset + j + k)\n",
-      "\u001b[1m\t\t\t\t\tscore += gamma[j, rr_inv[t_idx]]\n",
-      "\u001b[0m     \u001b[1m^\u001b[0m\u001b[0m\n",
-      "\n",
-      "\u001b[0m\u001b[1mDuring: resolving callee type: type(CPUDispatcher(<function _p_values at 0x709694269f80>))\u001b[0m\n",
-      "\u001b[0m\u001b[1mDuring: typing of call at /home/luna.kuleuven.be/u0166574/miniconda3/envs/crested_dev_torch/lib/python3.12/site-packages/tangermeme/tools/tomtom.py (341)\n",
-      "\u001b[0m\n",
-      "\u001b[0m\u001b[1mDuring: resolving callee type: type(CPUDispatcher(<function _p_values at 0x709694269f80>))\u001b[0m\n",
-      "\u001b[0m\u001b[1mDuring: typing of call at /home/luna.kuleuven.be/u0166574/miniconda3/envs/crested_dev_torch/lib/python3.12/site-packages/tangermeme/tools/tomtom.py (341)\n",
-      "\u001b[0m\n",
-      "\u001b[1m\n",
-      "File \"../../../miniconda3/envs/crested_dev_torch/lib/python3.12/site-packages/tangermeme/tools/tomtom.py\", line 341:\u001b[0m\n",
-      "\u001b[1mdef _tomtom(Q, T, Q_lens, T_lens, Q_norm, T_norm, rr_inv, rr_counts, n_nearest, \n",
-      "    <source elided>\n",
-      "\n",
-      "\u001b[1m\t\t_p_values(_gamma[pid], _B[pid], rr_inv, T_lens, nq, offset, \n",
-      "\u001b[0m  \u001b[1m^\u001b[0m\u001b[0m\n",
-      "\n",
-      "Warning: TOMTOM error while comparing patterns Astro_pos_patterns_3 and Astro_pos_patterns_0. Returning no match.\n",
-      "Error details: Failed in nopython mode pipeline (step: nopython frontend)\n",
-      "\u001b[1m\u001b[1m\u001b[1m\u001b[1mFailed in nopython mode pipeline (step: nopython frontend)\n",
-      "\u001b[1m\u001b[1mNo implementation of function Function(<built-in function iadd>) found for signature:\n",
-      " \n",
-      " >>> iadd(Literal[int](0), array(int32, 1d, C))\n",
-      " \n",
-      "There are 18 candidate implementations:\n",
-      "\u001b[1m     - Of which 16 did not match due to:\n",
-      "     Overload of function 'iadd': File: <numerous>: Line N/A.\n",
-      "       With argument(s): '(int64, array(int32, 1d, C))':\u001b[0m\n",
-      "\u001b[1m      No match.\u001b[0m\n",
-      "\u001b[1m     - Of which 2 did not match due to:\n",
-      "     Operator Overload in function 'iadd': File: unknown: Line unknown.\n",
-      "       With argument(s): '(int64, array(int32, 1d, C))':\u001b[0m\n",
-      "\u001b[1m      No match for registered cases:\n",
-      "       * (int64, int64) -> int64\n",
-      "       * (int64, uint64) -> int64\n",
-      "       * (uint64, int64) -> int64\n",
-      "       * (uint64, uint64) -> uint64\n",
-      "       * (float32, float32) -> float32\n",
-      "       * (float64, float64) -> float64\n",
-      "       * (complex64, complex64) -> complex64\n",
-      "       * (complex128, complex128) -> complex128\u001b[0m\n",
-      "\u001b[0m\n",
-      "\u001b[0m\u001b[1mDuring: typing of intrinsic-call at /home/luna.kuleuven.be/u0166574/miniconda3/envs/crested_dev_torch/lib/python3.12/site-packages/tangermeme/tools/tomtom.py (242)\u001b[0m\n",
-      "\u001b[1m\n",
-      "File \"../../../miniconda3/envs/crested_dev_torch/lib/python3.12/site-packages/tangermeme/tools/tomtom.py\", line 242:\u001b[0m\n",
-      "\u001b[1mdef _p_values(gamma, B_cdfs, rr_inv, T_lens, nq, offset, n_bins, results):\n",
-      "    <source elided>\n",
-      "\t\t\t\t\tj, t_idx = uint64(j), uint64(total_offset + j + k)\n",
-      "\u001b[1m\t\t\t\t\tscore += gamma[j, rr_inv[t_idx]]\n",
-      "\u001b[0m     \u001b[1m^\u001b[0m\u001b[0m\n",
-      "\n",
-      "\u001b[0m\u001b[1mDuring: resolving callee type: type(CPUDispatcher(<function _p_values at 0x709694269f80>))\u001b[0m\n",
-      "\u001b[0m\u001b[1mDuring: typing of call at /home/luna.kuleuven.be/u0166574/miniconda3/envs/crested_dev_torch/lib/python3.12/site-packages/tangermeme/tools/tomtom.py (341)\n",
-      "\u001b[0m\n",
-      "\u001b[0m\u001b[1mDuring: resolving callee type: type(CPUDispatcher(<function _p_values at 0x709694269f80>))\u001b[0m\n",
-      "\u001b[0m\u001b[1mDuring: typing of call at /home/luna.kuleuven.be/u0166574/miniconda3/envs/crested_dev_torch/lib/python3.12/site-packages/tangermeme/tools/tomtom.py (341)\n",
-      "\u001b[0m\n",
-      "\u001b[1m\n",
-      "File \"../../../miniconda3/envs/crested_dev_torch/lib/python3.12/site-packages/tangermeme/tools/tomtom.py\", line 341:\u001b[0m\n",
-      "\u001b[1mdef _tomtom(Q, T, Q_lens, T_lens, Q_norm, T_norm, rr_inv, rr_counts, n_nearest, \n",
-      "    <source elided>\n",
-      "\n",
-      "\u001b[1m\t\t_p_values(_gamma[pid], _B[pid], rr_inv, T_lens, nq, offset, \n",
-      "\u001b[0m  \u001b[1m^\u001b[0m\u001b[0m\n",
-      "\n",
-      "Warning: TOMTOM error while comparing patterns Astro_pos_patterns_1 and Astro_pos_patterns_2. Returning no match.\n",
-      "Error details: Failed in nopython mode pipeline (step: nopython frontend)\n",
-      "\u001b[1m\u001b[1m\u001b[1m\u001b[1mFailed in nopython mode pipeline (step: nopython frontend)\n",
-      "\u001b[1m\u001b[1mNo implementation of function Function(<built-in function iadd>) found for signature:\n",
-      " \n",
-      " >>> iadd(Literal[int](0), array(int32, 1d, C))\n",
-      " \n",
-      "There are 18 candidate implementations:\n",
-      "\u001b[1m     - Of which 16 did not match due to:\n",
-      "     Overload of function 'iadd': File: <numerous>: Line N/A.\n",
-      "       With argument(s): '(int64, array(int32, 1d, C))':\u001b[0m\n",
-      "\u001b[1m      No match.\u001b[0m\n",
-      "\u001b[1m     - Of which 2 did not match due to:\n",
-      "     Operator Overload in function 'iadd': File: unknown: Line unknown.\n",
-      "       With argument(s): '(int64, array(int32, 1d, C))':\u001b[0m\n",
-      "\u001b[1m      No match for registered cases:\n",
-      "       * (int64, int64) -> int64\n",
-      "       * (int64, uint64) -> int64\n",
-      "       * (uint64, int64) -> int64\n",
-      "       * (uint64, uint64) -> uint64\n",
-      "       * (float32, float32) -> float32\n",
-      "       * (float64, float64) -> float64\n",
-      "       * (complex64, complex64) -> complex64\n",
-      "       * (complex128, complex128) -> complex128\u001b[0m\n",
-      "\u001b[0m\n",
-      "\u001b[0m\u001b[1mDuring: typing of intrinsic-call at /home/luna.kuleuven.be/u0166574/miniconda3/envs/crested_dev_torch/lib/python3.12/site-packages/tangermeme/tools/tomtom.py (242)\u001b[0m\n",
-      "\u001b[1m\n",
-      "File \"../../../miniconda3/envs/crested_dev_torch/lib/python3.12/site-packages/tangermeme/tools/tomtom.py\", line 242:\u001b[0m\n",
-      "\u001b[1mdef _p_values(gamma, B_cdfs, rr_inv, T_lens, nq, offset, n_bins, results):\n",
-      "    <source elided>\n",
-      "\t\t\t\t\tj, t_idx = uint64(j), uint64(total_offset + j + k)\n",
-      "\u001b[1m\t\t\t\t\tscore += gamma[j, rr_inv[t_idx]]\n",
-      "\u001b[0m     \u001b[1m^\u001b[0m\u001b[0m\n",
-      "\n",
-      "\u001b[0m\u001b[1mDuring: resolving callee type: type(CPUDispatcher(<function _p_values at 0x709694269f80>))\u001b[0m\n",
-      "\u001b[0m\u001b[1mDuring: typing of call at /home/luna.kuleuven.be/u0166574/miniconda3/envs/crested_dev_torch/lib/python3.12/site-packages/tangermeme/tools/tomtom.py (341)\n",
-      "\u001b[0m\n",
-      "\u001b[0m\u001b[1mDuring: resolving callee type: type(CPUDispatcher(<function _p_values at 0x709694269f80>))\u001b[0m\n",
-      "\u001b[0m\u001b[1mDuring: typing of call at /home/luna.kuleuven.be/u0166574/miniconda3/envs/crested_dev_torch/lib/python3.12/site-packages/tangermeme/tools/tomtom.py (341)\n",
-      "\u001b[0m\n",
-      "\u001b[1m\n",
-      "File \"../../../miniconda3/envs/crested_dev_torch/lib/python3.12/site-packages/tangermeme/tools/tomtom.py\", line 341:\u001b[0m\n",
-      "\u001b[1mdef _tomtom(Q, T, Q_lens, T_lens, Q_norm, T_norm, rr_inv, rr_counts, n_nearest, \n",
-      "    <source elided>\n",
-      "\n",
-      "\u001b[1m\t\t_p_values(_gamma[pid], _B[pid], rr_inv, T_lens, nq, offset, \n",
-      "\u001b[0m  \u001b[1m^\u001b[0m\u001b[0m\n",
-      "\n",
-      "Warning: TOMTOM error while comparing patterns Astro_pos_patterns_2 and Astro_pos_patterns_1. Returning no match.\n",
-      "Error details: Failed in nopython mode pipeline (step: nopython frontend)\n",
-      "\u001b[1m\u001b[1m\u001b[1m\u001b[1mFailed in nopython mode pipeline (step: nopython frontend)\n",
-      "\u001b[1m\u001b[1mNo implementation of function Function(<built-in function iadd>) found for signature:\n",
-      " \n",
-      " >>> iadd(Literal[int](0), array(int32, 1d, C))\n",
-      " \n",
-      "There are 18 candidate implementations:\n",
-      "\u001b[1m     - Of which 16 did not match due to:\n",
-      "     Overload of function 'iadd': File: <numerous>: Line N/A.\n",
-      "       With argument(s): '(int64, array(int32, 1d, C))':\u001b[0m\n",
-      "\u001b[1m      No match.\u001b[0m\n",
-      "\u001b[1m     - Of which 2 did not match due to:\n",
-      "     Operator Overload in function 'iadd': File: unknown: Line unknown.\n",
-      "       With argument(s): '(int64, array(int32, 1d, C))':\u001b[0m\n",
-      "\u001b[1m      No match for registered cases:\n",
-      "       * (int64, int64) -> int64\n",
-      "       * (int64, uint64) -> int64\n",
-      "       * (uint64, int64) -> int64\n",
-      "       * (uint64, uint64) -> uint64\n",
-      "       * (float32, float32) -> float32\n",
-      "       * (float64, float64) -> float64\n",
-      "       * (complex64, complex64) -> complex64\n",
-      "       * (complex128, complex128) -> complex128\u001b[0m\n",
-      "\u001b[0m\n",
-      "\u001b[0m\u001b[1mDuring: typing of intrinsic-call at /home/luna.kuleuven.be/u0166574/miniconda3/envs/crested_dev_torch/lib/python3.12/site-packages/tangermeme/tools/tomtom.py (242)\u001b[0m\n",
-      "\u001b[1m\n",
-      "File \"../../../miniconda3/envs/crested_dev_torch/lib/python3.12/site-packages/tangermeme/tools/tomtom.py\", line 242:\u001b[0m\n",
-      "\u001b[1mdef _p_values(gamma, B_cdfs, rr_inv, T_lens, nq, offset, n_bins, results):\n",
-      "    <source elided>\n",
-      "\t\t\t\t\tj, t_idx = uint64(j), uint64(total_offset + j + k)\n",
-      "\u001b[1m\t\t\t\t\tscore += gamma[j, rr_inv[t_idx]]\n",
-      "\u001b[0m     \u001b[1m^\u001b[0m\u001b[0m\n",
-      "\n",
-      "\u001b[0m\u001b[1mDuring: resolving callee type: type(CPUDispatcher(<function _p_values at 0x709694269f80>))\u001b[0m\n",
-      "\u001b[0m\u001b[1mDuring: typing of call at /home/luna.kuleuven.be/u0166574/miniconda3/envs/crested_dev_torch/lib/python3.12/site-packages/tangermeme/tools/tomtom.py (341)\n",
-      "\u001b[0m\n",
-      "\u001b[0m\u001b[1mDuring: resolving callee type: type(CPUDispatcher(<function _p_values at 0x709694269f80>))\u001b[0m\n",
-      "\u001b[0m\u001b[1mDuring: typing of call at /home/luna.kuleuven.be/u0166574/miniconda3/envs/crested_dev_torch/lib/python3.12/site-packages/tangermeme/tools/tomtom.py (341)\n",
-      "\u001b[0m\n",
-      "\u001b[1m\n",
-      "File \"../../../miniconda3/envs/crested_dev_torch/lib/python3.12/site-packages/tangermeme/tools/tomtom.py\", line 341:\u001b[0m\n",
-      "\u001b[1mdef _tomtom(Q, T, Q_lens, T_lens, Q_norm, T_norm, rr_inv, rr_counts, n_nearest, \n",
-      "    <source elided>\n",
-      "\n",
-      "\u001b[1m\t\t_p_values(_gamma[pid], _B[pid], rr_inv, T_lens, nq, offset, \n",
-      "\u001b[0m  \u001b[1m^\u001b[0m\u001b[0m\n",
-      "\n",
-      "Warning: TOMTOM error while comparing patterns Astro_pos_patterns_1 and Astro_pos_patterns_3. Returning no match.\n",
-      "Error details: Failed in nopython mode pipeline (step: nopython frontend)\n",
-      "\u001b[1m\u001b[1m\u001b[1m\u001b[1mFailed in nopython mode pipeline (step: nopython frontend)\n",
-      "\u001b[1m\u001b[1mNo implementation of function Function(<built-in function iadd>) found for signature:\n",
-      " \n",
-      " >>> iadd(Literal[int](0), array(int32, 1d, C))\n",
-      " \n",
-      "There are 18 candidate implementations:\n",
-      "\u001b[1m     - Of which 16 did not match due to:\n",
-      "     Overload of function 'iadd': File: <numerous>: Line N/A.\n",
-      "       With argument(s): '(int64, array(int32, 1d, C))':\u001b[0m\n",
-      "\u001b[1m      No match.\u001b[0m\n",
-      "\u001b[1m     - Of which 2 did not match due to:\n",
-      "     Operator Overload in function 'iadd': File: unknown: Line unknown.\n",
-      "       With argument(s): '(int64, array(int32, 1d, C))':\u001b[0m\n",
-      "\u001b[1m      No match for registered cases:\n",
-      "       * (int64, int64) -> int64\n",
-      "       * (int64, uint64) -> int64\n",
-      "       * (uint64, int64) -> int64\n",
-      "       * (uint64, uint64) -> uint64\n",
-      "       * (float32, float32) -> float32\n",
-      "       * (float64, float64) -> float64\n",
-      "       * (complex64, complex64) -> complex64\n",
-      "       * (complex128, complex128) -> complex128\u001b[0m\n",
-      "\u001b[0m\n",
-      "\u001b[0m\u001b[1mDuring: typing of intrinsic-call at /home/luna.kuleuven.be/u0166574/miniconda3/envs/crested_dev_torch/lib/python3.12/site-packages/tangermeme/tools/tomtom.py (242)\u001b[0m\n",
-      "\u001b[1m\n",
-      "File \"../../../miniconda3/envs/crested_dev_torch/lib/python3.12/site-packages/tangermeme/tools/tomtom.py\", line 242:\u001b[0m\n",
-      "\u001b[1mdef _p_values(gamma, B_cdfs, rr_inv, T_lens, nq, offset, n_bins, results):\n",
-      "    <source elided>\n",
-      "\t\t\t\t\tj, t_idx = uint64(j), uint64(total_offset + j + k)\n",
-      "\u001b[1m\t\t\t\t\tscore += gamma[j, rr_inv[t_idx]]\n",
-      "\u001b[0m     \u001b[1m^\u001b[0m\u001b[0m\n",
-      "\n",
-      "\u001b[0m\u001b[1mDuring: resolving callee type: type(CPUDispatcher(<function _p_values at 0x709694269f80>))\u001b[0m\n",
-      "\u001b[0m\u001b[1mDuring: typing of call at /home/luna.kuleuven.be/u0166574/miniconda3/envs/crested_dev_torch/lib/python3.12/site-packages/tangermeme/tools/tomtom.py (341)\n",
-      "\u001b[0m\n",
-      "\u001b[0m\u001b[1mDuring: resolving callee type: type(CPUDispatcher(<function _p_values at 0x709694269f80>))\u001b[0m\n",
-      "\u001b[0m\u001b[1mDuring: typing of call at /home/luna.kuleuven.be/u0166574/miniconda3/envs/crested_dev_torch/lib/python3.12/site-packages/tangermeme/tools/tomtom.py (341)\n",
-      "\u001b[0m\n",
-      "\u001b[1m\n",
-      "File \"../../../miniconda3/envs/crested_dev_torch/lib/python3.12/site-packages/tangermeme/tools/tomtom.py\", line 341:\u001b[0m\n",
-      "\u001b[1mdef _tomtom(Q, T, Q_lens, T_lens, Q_norm, T_norm, rr_inv, rr_counts, n_nearest, \n",
-      "    <source elided>\n",
-      "\n",
-      "\u001b[1m\t\t_p_values(_gamma[pid], _B[pid], rr_inv, T_lens, nq, offset, \n",
-      "\u001b[0m  \u001b[1m^\u001b[0m\u001b[0m\n",
-      "\n",
-      "Warning: TOMTOM error while comparing patterns Astro_pos_patterns_3 and Astro_pos_patterns_1. Returning no match.\n",
-      "Error details: Failed in nopython mode pipeline (step: nopython frontend)\n",
-      "\u001b[1m\u001b[1m\u001b[1m\u001b[1mFailed in nopython mode pipeline (step: nopython frontend)\n",
-      "\u001b[1m\u001b[1mNo implementation of function Function(<built-in function iadd>) found for signature:\n",
-      " \n",
-      " >>> iadd(Literal[int](0), array(int32, 1d, C))\n",
-      " \n",
-      "There are 18 candidate implementations:\n",
-      "\u001b[1m     - Of which 16 did not match due to:\n",
-      "     Overload of function 'iadd': File: <numerous>: Line N/A.\n",
-      "       With argument(s): '(int64, array(int32, 1d, C))':\u001b[0m\n",
-      "\u001b[1m      No match.\u001b[0m\n",
-      "\u001b[1m     - Of which 2 did not match due to:\n",
-      "     Operator Overload in function 'iadd': File: unknown: Line unknown.\n",
-      "       With argument(s): '(int64, array(int32, 1d, C))':\u001b[0m\n",
-      "\u001b[1m      No match for registered cases:\n",
-      "       * (int64, int64) -> int64\n",
-      "       * (int64, uint64) -> int64\n",
-      "       * (uint64, int64) -> int64\n",
-      "       * (uint64, uint64) -> uint64\n",
-      "       * (float32, float32) -> float32\n",
-      "       * (float64, float64) -> float64\n",
-      "       * (complex64, complex64) -> complex64\n",
-      "       * (complex128, complex128) -> complex128\u001b[0m\n",
-      "\u001b[0m\n",
-      "\u001b[0m\u001b[1mDuring: typing of intrinsic-call at /home/luna.kuleuven.be/u0166574/miniconda3/envs/crested_dev_torch/lib/python3.12/site-packages/tangermeme/tools/tomtom.py (242)\u001b[0m\n",
-      "\u001b[1m\n",
-      "File \"../../../miniconda3/envs/crested_dev_torch/lib/python3.12/site-packages/tangermeme/tools/tomtom.py\", line 242:\u001b[0m\n",
-      "\u001b[1mdef _p_values(gamma, B_cdfs, rr_inv, T_lens, nq, offset, n_bins, results):\n",
-      "    <source elided>\n",
-      "\t\t\t\t\tj, t_idx = uint64(j), uint64(total_offset + j + k)\n",
-      "\u001b[1m\t\t\t\t\tscore += gamma[j, rr_inv[t_idx]]\n",
-      "\u001b[0m     \u001b[1m^\u001b[0m\u001b[0m\n",
-      "\n",
-      "\u001b[0m\u001b[1mDuring: resolving callee type: type(CPUDispatcher(<function _p_values at 0x709694269f80>))\u001b[0m\n",
-      "\u001b[0m\u001b[1mDuring: typing of call at /home/luna.kuleuven.be/u0166574/miniconda3/envs/crested_dev_torch/lib/python3.12/site-packages/tangermeme/tools/tomtom.py (341)\n",
-      "\u001b[0m\n",
-      "\u001b[0m\u001b[1mDuring: resolving callee type: type(CPUDispatcher(<function _p_values at 0x709694269f80>))\u001b[0m\n",
-      "\u001b[0m\u001b[1mDuring: typing of call at /home/luna.kuleuven.be/u0166574/miniconda3/envs/crested_dev_torch/lib/python3.12/site-packages/tangermeme/tools/tomtom.py (341)\n",
-      "\u001b[0m\n",
-      "\u001b[1m\n",
-      "File \"../../../miniconda3/envs/crested_dev_torch/lib/python3.12/site-packages/tangermeme/tools/tomtom.py\", line 341:\u001b[0m\n",
-      "\u001b[1mdef _tomtom(Q, T, Q_lens, T_lens, Q_norm, T_norm, rr_inv, rr_counts, n_nearest, \n",
-      "    <source elided>\n",
-      "\n",
-      "\u001b[1m\t\t_p_values(_gamma[pid], _B[pid], rr_inv, T_lens, nq, offset, \n",
-      "\u001b[0m  \u001b[1m^\u001b[0m\u001b[0m\n",
-      "\n",
-      "Warning: TOMTOM error while comparing patterns Astro_pos_patterns_2 and Astro_pos_patterns_3. Returning no match.\n",
-      "Error details: Failed in nopython mode pipeline (step: nopython frontend)\n",
-      "\u001b[1m\u001b[1m\u001b[1m\u001b[1mFailed in nopython mode pipeline (step: nopython frontend)\n",
-      "\u001b[1m\u001b[1mNo implementation of function Function(<built-in function iadd>) found for signature:\n",
-      " \n",
-      " >>> iadd(Literal[int](0), array(int32, 1d, C))\n",
-      " \n",
-      "There are 18 candidate implementations:\n",
-      "\u001b[1m     - Of which 16 did not match due to:\n",
-      "     Overload of function 'iadd': File: <numerous>: Line N/A.\n",
-      "       With argument(s): '(int64, array(int32, 1d, C))':\u001b[0m\n",
-      "\u001b[1m      No match.\u001b[0m\n",
-      "\u001b[1m     - Of which 2 did not match due to:\n",
-      "     Operator Overload in function 'iadd': File: unknown: Line unknown.\n",
-      "       With argument(s): '(int64, array(int32, 1d, C))':\u001b[0m\n",
-      "\u001b[1m      No match for registered cases:\n",
-      "       * (int64, int64) -> int64\n",
-      "       * (int64, uint64) -> int64\n",
-      "       * (uint64, int64) -> int64\n",
-      "       * (uint64, uint64) -> uint64\n",
-      "       * (float32, float32) -> float32\n",
-      "       * (float64, float64) -> float64\n",
-      "       * (complex64, complex64) -> complex64\n",
-      "       * (complex128, complex128) -> complex128\u001b[0m\n",
-      "\u001b[0m\n",
-      "\u001b[0m\u001b[1mDuring: typing of intrinsic-call at /home/luna.kuleuven.be/u0166574/miniconda3/envs/crested_dev_torch/lib/python3.12/site-packages/tangermeme/tools/tomtom.py (242)\u001b[0m\n",
-      "\u001b[1m\n",
-      "File \"../../../miniconda3/envs/crested_dev_torch/lib/python3.12/site-packages/tangermeme/tools/tomtom.py\", line 242:\u001b[0m\n",
-      "\u001b[1mdef _p_values(gamma, B_cdfs, rr_inv, T_lens, nq, offset, n_bins, results):\n",
-      "    <source elided>\n",
-      "\t\t\t\t\tj, t_idx = uint64(j), uint64(total_offset + j + k)\n",
-      "\u001b[1m\t\t\t\t\tscore += gamma[j, rr_inv[t_idx]]\n",
-      "\u001b[0m     \u001b[1m^\u001b[0m\u001b[0m\n",
-      "\n",
-      "\u001b[0m\u001b[1mDuring: resolving callee type: type(CPUDispatcher(<function _p_values at 0x709694269f80>))\u001b[0m\n",
-      "\u001b[0m\u001b[1mDuring: typing of call at /home/luna.kuleuven.be/u0166574/miniconda3/envs/crested_dev_torch/lib/python3.12/site-packages/tangermeme/tools/tomtom.py (341)\n",
-      "\u001b[0m\n",
-      "\u001b[0m\u001b[1mDuring: resolving callee type: type(CPUDispatcher(<function _p_values at 0x709694269f80>))\u001b[0m\n",
-      "\u001b[0m\u001b[1mDuring: typing of call at /home/luna.kuleuven.be/u0166574/miniconda3/envs/crested_dev_torch/lib/python3.12/site-packages/tangermeme/tools/tomtom.py (341)\n",
-      "\u001b[0m\n",
-      "\u001b[1m\n",
-      "File \"../../../miniconda3/envs/crested_dev_torch/lib/python3.12/site-packages/tangermeme/tools/tomtom.py\", line 341:\u001b[0m\n",
-      "\u001b[1mdef _tomtom(Q, T, Q_lens, T_lens, Q_norm, T_norm, rr_inv, rr_counts, n_nearest, \n",
-      "    <source elided>\n",
-      "\n",
-      "\u001b[1m\t\t_p_values(_gamma[pid], _B[pid], rr_inv, T_lens, nq, offset, \n",
-      "\u001b[0m  \u001b[1m^\u001b[0m\u001b[0m\n",
-      "\n",
-      "Warning: TOMTOM error while comparing patterns Astro_pos_patterns_3 and Astro_pos_patterns_2. Returning no match.\n",
-      "Error details: Failed in nopython mode pipeline (step: nopython frontend)\n",
-      "\u001b[1m\u001b[1m\u001b[1m\u001b[1mFailed in nopython mode pipeline (step: nopython frontend)\n",
-      "\u001b[1m\u001b[1mNo implementation of function Function(<built-in function iadd>) found for signature:\n",
-      " \n",
-      " >>> iadd(Literal[int](0), array(int32, 1d, C))\n",
-      " \n",
-      "There are 18 candidate implementations:\n",
-      "\u001b[1m     - Of which 16 did not match due to:\n",
-      "     Overload of function 'iadd': File: <numerous>: Line N/A.\n",
-      "       With argument(s): '(int64, array(int32, 1d, C))':\u001b[0m\n",
-      "\u001b[1m      No match.\u001b[0m\n",
-      "\u001b[1m     - Of which 2 did not match due to:\n",
-      "     Operator Overload in function 'iadd': File: unknown: Line unknown.\n",
-      "       With argument(s): '(int64, array(int32, 1d, C))':\u001b[0m\n",
-      "\u001b[1m      No match for registered cases:\n",
-      "       * (int64, int64) -> int64\n",
-      "       * (int64, uint64) -> int64\n",
-      "       * (uint64, int64) -> int64\n",
-      "       * (uint64, uint64) -> uint64\n",
-      "       * (float32, float32) -> float32\n",
-      "       * (float64, float64) -> float64\n",
-      "       * (complex64, complex64) -> complex64\n",
-      "       * (complex128, complex128) -> complex128\u001b[0m\n",
-      "\u001b[0m\n",
-      "\u001b[0m\u001b[1mDuring: typing of intrinsic-call at /home/luna.kuleuven.be/u0166574/miniconda3/envs/crested_dev_torch/lib/python3.12/site-packages/tangermeme/tools/tomtom.py (242)\u001b[0m\n",
-      "\u001b[1m\n",
-      "File \"../../../miniconda3/envs/crested_dev_torch/lib/python3.12/site-packages/tangermeme/tools/tomtom.py\", line 242:\u001b[0m\n",
-      "\u001b[1mdef _p_values(gamma, B_cdfs, rr_inv, T_lens, nq, offset, n_bins, results):\n",
-      "    <source elided>\n",
-      "\t\t\t\t\tj, t_idx = uint64(j), uint64(total_offset + j + k)\n",
-      "\u001b[1m\t\t\t\t\tscore += gamma[j, rr_inv[t_idx]]\n",
-      "\u001b[0m     \u001b[1m^\u001b[0m\u001b[0m\n",
-      "\n",
-      "\u001b[0m\u001b[1mDuring: resolving callee type: type(CPUDispatcher(<function _p_values at 0x709694269f80>))\u001b[0m\n",
-      "\u001b[0m\u001b[1mDuring: typing of call at /home/luna.kuleuven.be/u0166574/miniconda3/envs/crested_dev_torch/lib/python3.12/site-packages/tangermeme/tools/tomtom.py (341)\n",
-      "\u001b[0m\n",
-      "\u001b[0m\u001b[1mDuring: resolving callee type: type(CPUDispatcher(<function _p_values at 0x709694269f80>))\u001b[0m\n",
-      "\u001b[0m\u001b[1mDuring: typing of call at /home/luna.kuleuven.be/u0166574/miniconda3/envs/crested_dev_torch/lib/python3.12/site-packages/tangermeme/tools/tomtom.py (341)\n",
-      "\u001b[0m\n",
-      "\u001b[1m\n",
-      "File \"../../../miniconda3/envs/crested_dev_torch/lib/python3.12/site-packages/tangermeme/tools/tomtom.py\", line 341:\u001b[0m\n",
-      "\u001b[1mdef _tomtom(Q, T, Q_lens, T_lens, Q_norm, T_norm, rr_inv, rr_counts, n_nearest, \n",
-      "    <source elided>\n",
-      "\n",
-      "\u001b[1m\t\t_p_values(_gamma[pid], _B[pid], rr_inv, T_lens, nq, offset, \n",
-      "\u001b[0m  \u001b[1m^\u001b[0m\u001b[0m\n",
-      "\n",
+      "Match between Astro_neg_patterns_5 and Astro_neg_patterns_2 with similarity score 1.83\n",
+      "Match between Astro_pos_patterns_0 and Astro_neg_patterns_1 with similarity score 3.22\n",
+      "Match between Astro_pos_patterns_4 and Astro_pos_patterns_3 with similarity score 3.69\n",
+      "Match between Astro_pos_patterns_5 and Astro_pos_patterns_1 with similarity score 1.77\n",
+      "Match between Astro_pos_patterns_6 and Astro_neg_patterns_3 with similarity score 2.86\n",
+      "Match between Astro_pos_patterns_10 and Astro_pos_patterns_7 with similarity score 7.18\n",
+      "Match between Astro_pos_patterns_11 and Astro_pos_patterns_10 with similarity score 4.06\n",
+      "Match between Astro_pos_patterns_12 and Astro_pos_patterns_5 with similarity score 2.65\n",
+      "Match between Astro_pos_patterns_14 and Astro_pos_patterns_4 with similarity score 4.84\n",
+      "Merged patterns Astro_pos_patterns_2 and Astro_pos_patterns_10 with similarity 4.784636823321841\n",
+      "Iteration 1: Merging complete, checking again\n",
       "Discarded 0 patterns below IC threshold 0.2 and with a single class instance:\n",
       "[]\n",
-      "Total iterations: 0\n",
-      "Warning: TOMTOM error while comparing patterns Astro_pos_patterns_0 and Astro_pos_patterns_1. Returning no match.\n",
-      "Error details: Failed in nopython mode pipeline (step: nopython frontend)\n",
-      "\u001b[1m\u001b[1m\u001b[1m\u001b[1mFailed in nopython mode pipeline (step: nopython frontend)\n",
-      "\u001b[1m\u001b[1mNo implementation of function Function(<built-in function iadd>) found for signature:\n",
-      " \n",
-      " >>> iadd(Literal[int](0), array(int32, 1d, C))\n",
-      " \n",
-      "There are 18 candidate implementations:\n",
-      "\u001b[1m     - Of which 16 did not match due to:\n",
-      "     Overload of function 'iadd': File: <numerous>: Line N/A.\n",
-      "       With argument(s): '(int64, array(int32, 1d, C))':\u001b[0m\n",
-      "\u001b[1m      No match.\u001b[0m\n",
-      "\u001b[1m     - Of which 2 did not match due to:\n",
-      "     Operator Overload in function 'iadd': File: unknown: Line unknown.\n",
-      "       With argument(s): '(int64, array(int32, 1d, C))':\u001b[0m\n",
-      "\u001b[1m      No match for registered cases:\n",
-      "       * (int64, int64) -> int64\n",
-      "       * (int64, uint64) -> int64\n",
-      "       * (uint64, int64) -> int64\n",
-      "       * (uint64, uint64) -> uint64\n",
-      "       * (float32, float32) -> float32\n",
-      "       * (float64, float64) -> float64\n",
-      "       * (complex64, complex64) -> complex64\n",
-      "       * (complex128, complex128) -> complex128\u001b[0m\n",
-      "\u001b[0m\n",
-      "\u001b[0m\u001b[1mDuring: typing of intrinsic-call at /home/luna.kuleuven.be/u0166574/miniconda3/envs/crested_dev_torch/lib/python3.12/site-packages/tangermeme/tools/tomtom.py (242)\u001b[0m\n",
-      "\u001b[1m\n",
-      "File \"../../../miniconda3/envs/crested_dev_torch/lib/python3.12/site-packages/tangermeme/tools/tomtom.py\", line 242:\u001b[0m\n",
-      "\u001b[1mdef _p_values(gamma, B_cdfs, rr_inv, T_lens, nq, offset, n_bins, results):\n",
-      "    <source elided>\n",
-      "\t\t\t\t\tj, t_idx = uint64(j), uint64(total_offset + j + k)\n",
-      "\u001b[1m\t\t\t\t\tscore += gamma[j, rr_inv[t_idx]]\n",
-      "\u001b[0m     \u001b[1m^\u001b[0m\u001b[0m\n",
-      "\n",
-      "\u001b[0m\u001b[1mDuring: resolving callee type: type(CPUDispatcher(<function _p_values at 0x709694269f80>))\u001b[0m\n",
-      "\u001b[0m\u001b[1mDuring: typing of call at /home/luna.kuleuven.be/u0166574/miniconda3/envs/crested_dev_torch/lib/python3.12/site-packages/tangermeme/tools/tomtom.py (341)\n",
-      "\u001b[0m\n",
-      "\u001b[0m\u001b[1mDuring: resolving callee type: type(CPUDispatcher(<function _p_values at 0x709694269f80>))\u001b[0m\n",
-      "\u001b[0m\u001b[1mDuring: typing of call at /home/luna.kuleuven.be/u0166574/miniconda3/envs/crested_dev_torch/lib/python3.12/site-packages/tangermeme/tools/tomtom.py (341)\n",
-      "\u001b[0m\n",
-      "\u001b[1m\n",
-      "File \"../../../miniconda3/envs/crested_dev_torch/lib/python3.12/site-packages/tangermeme/tools/tomtom.py\", line 341:\u001b[0m\n",
-      "\u001b[1mdef _tomtom(Q, T, Q_lens, T_lens, Q_norm, T_norm, rr_inv, rr_counts, n_nearest, \n",
-      "    <source elided>\n",
-      "\n",
-      "\u001b[1m\t\t_p_values(_gamma[pid], _B[pid], rr_inv, T_lens, nq, offset, \n",
-      "\u001b[0m  \u001b[1m^\u001b[0m\u001b[0m\n",
-      "\n",
-      "Warning: TOMTOM error while comparing patterns Astro_pos_patterns_1 and Astro_pos_patterns_0. Returning no match.\n",
-      "Error details: Failed in nopython mode pipeline (step: nopython frontend)\n",
-      "\u001b[1m\u001b[1m\u001b[1m\u001b[1mFailed in nopython mode pipeline (step: nopython frontend)\n",
-      "\u001b[1m\u001b[1mNo implementation of function Function(<built-in function iadd>) found for signature:\n",
-      " \n",
-      " >>> iadd(Literal[int](0), array(int32, 1d, C))\n",
-      " \n",
-      "There are 18 candidate implementations:\n",
-      "\u001b[1m     - Of which 16 did not match due to:\n",
-      "     Overload of function 'iadd': File: <numerous>: Line N/A.\n",
-      "       With argument(s): '(int64, array(int32, 1d, C))':\u001b[0m\n",
-      "\u001b[1m      No match.\u001b[0m\n",
-      "\u001b[1m     - Of which 2 did not match due to:\n",
-      "     Operator Overload in function 'iadd': File: unknown: Line unknown.\n",
-      "       With argument(s): '(int64, array(int32, 1d, C))':\u001b[0m\n",
-      "\u001b[1m      No match for registered cases:\n",
-      "       * (int64, int64) -> int64\n",
-      "       * (int64, uint64) -> int64\n",
-      "       * (uint64, int64) -> int64\n",
-      "       * (uint64, uint64) -> uint64\n",
-      "       * (float32, float32) -> float32\n",
-      "       * (float64, float64) -> float64\n",
-      "       * (complex64, complex64) -> complex64\n",
-      "       * (complex128, complex128) -> complex128\u001b[0m\n",
-      "\u001b[0m\n",
-      "\u001b[0m\u001b[1mDuring: typing of intrinsic-call at /home/luna.kuleuven.be/u0166574/miniconda3/envs/crested_dev_torch/lib/python3.12/site-packages/tangermeme/tools/tomtom.py (242)\u001b[0m\n",
-      "\u001b[1m\n",
-      "File \"../../../miniconda3/envs/crested_dev_torch/lib/python3.12/site-packages/tangermeme/tools/tomtom.py\", line 242:\u001b[0m\n",
-      "\u001b[1mdef _p_values(gamma, B_cdfs, rr_inv, T_lens, nq, offset, n_bins, results):\n",
-      "    <source elided>\n",
-      "\t\t\t\t\tj, t_idx = uint64(j), uint64(total_offset + j + k)\n",
-      "\u001b[1m\t\t\t\t\tscore += gamma[j, rr_inv[t_idx]]\n",
-      "\u001b[0m     \u001b[1m^\u001b[0m\u001b[0m\n",
-      "\n",
-      "\u001b[0m\u001b[1mDuring: resolving callee type: type(CPUDispatcher(<function _p_values at 0x709694269f80>))\u001b[0m\n",
-      "\u001b[0m\u001b[1mDuring: typing of call at /home/luna.kuleuven.be/u0166574/miniconda3/envs/crested_dev_torch/lib/python3.12/site-packages/tangermeme/tools/tomtom.py (341)\n",
-      "\u001b[0m\n",
-      "\u001b[0m\u001b[1mDuring: resolving callee type: type(CPUDispatcher(<function _p_values at 0x709694269f80>))\u001b[0m\n",
-      "\u001b[0m\u001b[1mDuring: typing of call at /home/luna.kuleuven.be/u0166574/miniconda3/envs/crested_dev_torch/lib/python3.12/site-packages/tangermeme/tools/tomtom.py (341)\n",
-      "\u001b[0m\n",
-      "\u001b[1m\n",
-      "File \"../../../miniconda3/envs/crested_dev_torch/lib/python3.12/site-packages/tangermeme/tools/tomtom.py\", line 341:\u001b[0m\n",
-      "\u001b[1mdef _tomtom(Q, T, Q_lens, T_lens, Q_norm, T_norm, rr_inv, rr_counts, n_nearest, \n",
-      "    <source elided>\n",
-      "\n",
-      "\u001b[1m\t\t_p_values(_gamma[pid], _B[pid], rr_inv, T_lens, nq, offset, \n",
-      "\u001b[0m  \u001b[1m^\u001b[0m\u001b[0m\n",
-      "\n",
-      "Warning: TOMTOM error while comparing patterns Astro_pos_patterns_0 and Astro_pos_patterns_2. Returning no match.\n",
-      "Error details: Failed in nopython mode pipeline (step: nopython frontend)\n",
-      "\u001b[1m\u001b[1m\u001b[1m\u001b[1mFailed in nopython mode pipeline (step: nopython frontend)\n",
-      "\u001b[1m\u001b[1mNo implementation of function Function(<built-in function iadd>) found for signature:\n",
-      " \n",
-      " >>> iadd(Literal[int](0), array(int32, 1d, C))\n",
-      " \n",
-      "There are 18 candidate implementations:\n",
-      "\u001b[1m     - Of which 16 did not match due to:\n",
-      "     Overload of function 'iadd': File: <numerous>: Line N/A.\n",
-      "       With argument(s): '(int64, array(int32, 1d, C))':\u001b[0m\n",
-      "\u001b[1m      No match.\u001b[0m\n",
-      "\u001b[1m     - Of which 2 did not match due to:\n",
-      "     Operator Overload in function 'iadd': File: unknown: Line unknown.\n",
-      "       With argument(s): '(int64, array(int32, 1d, C))':\u001b[0m\n",
-      "\u001b[1m      No match for registered cases:\n",
-      "       * (int64, int64) -> int64\n",
-      "       * (int64, uint64) -> int64\n",
-      "       * (uint64, int64) -> int64\n",
-      "       * (uint64, uint64) -> uint64\n",
-      "       * (float32, float32) -> float32\n",
-      "       * (float64, float64) -> float64\n",
-      "       * (complex64, complex64) -> complex64\n",
-      "       * (complex128, complex128) -> complex128\u001b[0m\n",
-      "\u001b[0m\n",
-      "\u001b[0m\u001b[1mDuring: typing of intrinsic-call at /home/luna.kuleuven.be/u0166574/miniconda3/envs/crested_dev_torch/lib/python3.12/site-packages/tangermeme/tools/tomtom.py (242)\u001b[0m\n",
-      "\u001b[1m\n",
-      "File \"../../../miniconda3/envs/crested_dev_torch/lib/python3.12/site-packages/tangermeme/tools/tomtom.py\", line 242:\u001b[0m\n",
-      "\u001b[1mdef _p_values(gamma, B_cdfs, rr_inv, T_lens, nq, offset, n_bins, results):\n",
-      "    <source elided>\n",
-      "\t\t\t\t\tj, t_idx = uint64(j), uint64(total_offset + j + k)\n",
-      "\u001b[1m\t\t\t\t\tscore += gamma[j, rr_inv[t_idx]]\n",
-      "\u001b[0m     \u001b[1m^\u001b[0m\u001b[0m\n",
-      "\n",
-      "\u001b[0m\u001b[1mDuring: resolving callee type: type(CPUDispatcher(<function _p_values at 0x709694269f80>))\u001b[0m\n",
-      "\u001b[0m\u001b[1mDuring: typing of call at /home/luna.kuleuven.be/u0166574/miniconda3/envs/crested_dev_torch/lib/python3.12/site-packages/tangermeme/tools/tomtom.py (341)\n",
-      "\u001b[0m\n",
-      "\u001b[0m\u001b[1mDuring: resolving callee type: type(CPUDispatcher(<function _p_values at 0x709694269f80>))\u001b[0m\n",
-      "\u001b[0m\u001b[1mDuring: typing of call at /home/luna.kuleuven.be/u0166574/miniconda3/envs/crested_dev_torch/lib/python3.12/site-packages/tangermeme/tools/tomtom.py (341)\n",
-      "\u001b[0m\n",
-      "\u001b[1m\n",
-      "File \"../../../miniconda3/envs/crested_dev_torch/lib/python3.12/site-packages/tangermeme/tools/tomtom.py\", line 341:\u001b[0m\n",
-      "\u001b[1mdef _tomtom(Q, T, Q_lens, T_lens, Q_norm, T_norm, rr_inv, rr_counts, n_nearest, \n",
-      "    <source elided>\n",
-      "\n",
-      "\u001b[1m\t\t_p_values(_gamma[pid], _B[pid], rr_inv, T_lens, nq, offset, \n",
-      "\u001b[0m  \u001b[1m^\u001b[0m\u001b[0m\n",
-      "\n",
-      "Warning: TOMTOM error while comparing patterns Astro_pos_patterns_2 and Astro_pos_patterns_0. Returning no match.\n",
-      "Error details: Failed in nopython mode pipeline (step: nopython frontend)\n",
-      "\u001b[1m\u001b[1m\u001b[1m\u001b[1mFailed in nopython mode pipeline (step: nopython frontend)\n",
-      "\u001b[1m\u001b[1mNo implementation of function Function(<built-in function iadd>) found for signature:\n",
-      " \n",
-      " >>> iadd(Literal[int](0), array(int32, 1d, C))\n",
-      " \n",
-      "There are 18 candidate implementations:\n",
-      "\u001b[1m     - Of which 16 did not match due to:\n",
-      "     Overload of function 'iadd': File: <numerous>: Line N/A.\n",
-      "       With argument(s): '(int64, array(int32, 1d, C))':\u001b[0m\n",
-      "\u001b[1m      No match.\u001b[0m\n",
-      "\u001b[1m     - Of which 2 did not match due to:\n",
-      "     Operator Overload in function 'iadd': File: unknown: Line unknown.\n",
-      "       With argument(s): '(int64, array(int32, 1d, C))':\u001b[0m\n",
-      "\u001b[1m      No match for registered cases:\n",
-      "       * (int64, int64) -> int64\n",
-      "       * (int64, uint64) -> int64\n",
-      "       * (uint64, int64) -> int64\n",
-      "       * (uint64, uint64) -> uint64\n",
-      "       * (float32, float32) -> float32\n",
-      "       * (float64, float64) -> float64\n",
-      "       * (complex64, complex64) -> complex64\n",
-      "       * (complex128, complex128) -> complex128\u001b[0m\n",
-      "\u001b[0m\n",
-      "\u001b[0m\u001b[1mDuring: typing of intrinsic-call at /home/luna.kuleuven.be/u0166574/miniconda3/envs/crested_dev_torch/lib/python3.12/site-packages/tangermeme/tools/tomtom.py (242)\u001b[0m\n",
-      "\u001b[1m\n",
-      "File \"../../../miniconda3/envs/crested_dev_torch/lib/python3.12/site-packages/tangermeme/tools/tomtom.py\", line 242:\u001b[0m\n",
-      "\u001b[1mdef _p_values(gamma, B_cdfs, rr_inv, T_lens, nq, offset, n_bins, results):\n",
-      "    <source elided>\n",
-      "\t\t\t\t\tj, t_idx = uint64(j), uint64(total_offset + j + k)\n",
-      "\u001b[1m\t\t\t\t\tscore += gamma[j, rr_inv[t_idx]]\n",
-      "\u001b[0m     \u001b[1m^\u001b[0m\u001b[0m\n",
-      "\n",
-      "\u001b[0m\u001b[1mDuring: resolving callee type: type(CPUDispatcher(<function _p_values at 0x709694269f80>))\u001b[0m\n",
-      "\u001b[0m\u001b[1mDuring: typing of call at /home/luna.kuleuven.be/u0166574/miniconda3/envs/crested_dev_torch/lib/python3.12/site-packages/tangermeme/tools/tomtom.py (341)\n",
-      "\u001b[0m\n",
-      "\u001b[0m\u001b[1mDuring: resolving callee type: type(CPUDispatcher(<function _p_values at 0x709694269f80>))\u001b[0m\n",
-      "\u001b[0m\u001b[1mDuring: typing of call at /home/luna.kuleuven.be/u0166574/miniconda3/envs/crested_dev_torch/lib/python3.12/site-packages/tangermeme/tools/tomtom.py (341)\n",
-      "\u001b[0m\n",
-      "\u001b[1m\n",
-      "File \"../../../miniconda3/envs/crested_dev_torch/lib/python3.12/site-packages/tangermeme/tools/tomtom.py\", line 341:\u001b[0m\n",
-      "\u001b[1mdef _tomtom(Q, T, Q_lens, T_lens, Q_norm, T_norm, rr_inv, rr_counts, n_nearest, \n",
-      "    <source elided>\n",
-      "\n",
-      "\u001b[1m\t\t_p_values(_gamma[pid], _B[pid], rr_inv, T_lens, nq, offset, \n",
-      "\u001b[0m  \u001b[1m^\u001b[0m\u001b[0m\n",
-      "\n",
-      "Warning: TOMTOM error while comparing patterns Astro_pos_patterns_0 and Astro_pos_patterns_3. Returning no match.\n",
-      "Error details: Failed in nopython mode pipeline (step: nopython frontend)\n",
-      "\u001b[1m\u001b[1m\u001b[1m\u001b[1mFailed in nopython mode pipeline (step: nopython frontend)\n",
-      "\u001b[1m\u001b[1mNo implementation of function Function(<built-in function iadd>) found for signature:\n",
-      " \n",
-      " >>> iadd(Literal[int](0), array(int32, 1d, C))\n",
-      " \n",
-      "There are 18 candidate implementations:\n",
-      "\u001b[1m     - Of which 16 did not match due to:\n",
-      "     Overload of function 'iadd': File: <numerous>: Line N/A.\n",
-      "       With argument(s): '(int64, array(int32, 1d, C))':\u001b[0m\n",
-      "\u001b[1m      No match.\u001b[0m\n",
-      "\u001b[1m     - Of which 2 did not match due to:\n",
-      "     Operator Overload in function 'iadd': File: unknown: Line unknown.\n",
-      "       With argument(s): '(int64, array(int32, 1d, C))':\u001b[0m\n",
-      "\u001b[1m      No match for registered cases:\n",
-      "       * (int64, int64) -> int64\n",
-      "       * (int64, uint64) -> int64\n",
-      "       * (uint64, int64) -> int64\n",
-      "       * (uint64, uint64) -> uint64\n",
-      "       * (float32, float32) -> float32\n",
-      "       * (float64, float64) -> float64\n",
-      "       * (complex64, complex64) -> complex64\n",
-      "       * (complex128, complex128) -> complex128\u001b[0m\n",
-      "\u001b[0m\n",
-      "\u001b[0m\u001b[1mDuring: typing of intrinsic-call at /home/luna.kuleuven.be/u0166574/miniconda3/envs/crested_dev_torch/lib/python3.12/site-packages/tangermeme/tools/tomtom.py (242)\u001b[0m\n",
-      "\u001b[1m\n",
-      "File \"../../../miniconda3/envs/crested_dev_torch/lib/python3.12/site-packages/tangermeme/tools/tomtom.py\", line 242:\u001b[0m\n",
-      "\u001b[1mdef _p_values(gamma, B_cdfs, rr_inv, T_lens, nq, offset, n_bins, results):\n",
-      "    <source elided>\n",
-      "\t\t\t\t\tj, t_idx = uint64(j), uint64(total_offset + j + k)\n",
-      "\u001b[1m\t\t\t\t\tscore += gamma[j, rr_inv[t_idx]]\n",
-      "\u001b[0m     \u001b[1m^\u001b[0m\u001b[0m\n",
-      "\n",
-      "\u001b[0m\u001b[1mDuring: resolving callee type: type(CPUDispatcher(<function _p_values at 0x709694269f80>))\u001b[0m\n",
-      "\u001b[0m\u001b[1mDuring: typing of call at /home/luna.kuleuven.be/u0166574/miniconda3/envs/crested_dev_torch/lib/python3.12/site-packages/tangermeme/tools/tomtom.py (341)\n",
-      "\u001b[0m\n",
-      "\u001b[0m\u001b[1mDuring: resolving callee type: type(CPUDispatcher(<function _p_values at 0x709694269f80>))\u001b[0m\n",
-      "\u001b[0m\u001b[1mDuring: typing of call at /home/luna.kuleuven.be/u0166574/miniconda3/envs/crested_dev_torch/lib/python3.12/site-packages/tangermeme/tools/tomtom.py (341)\n",
-      "\u001b[0m\n",
-      "\u001b[1m\n",
-      "File \"../../../miniconda3/envs/crested_dev_torch/lib/python3.12/site-packages/tangermeme/tools/tomtom.py\", line 341:\u001b[0m\n",
-      "\u001b[1mdef _tomtom(Q, T, Q_lens, T_lens, Q_norm, T_norm, rr_inv, rr_counts, n_nearest, \n",
-      "    <source elided>\n",
-      "\n",
-      "\u001b[1m\t\t_p_values(_gamma[pid], _B[pid], rr_inv, T_lens, nq, offset, \n",
-      "\u001b[0m  \u001b[1m^\u001b[0m\u001b[0m\n",
-      "\n",
-      "Warning: TOMTOM error while comparing patterns Astro_pos_patterns_3 and Astro_pos_patterns_0. Returning no match.\n",
-      "Error details: Failed in nopython mode pipeline (step: nopython frontend)\n",
-      "\u001b[1m\u001b[1m\u001b[1m\u001b[1mFailed in nopython mode pipeline (step: nopython frontend)\n",
-      "\u001b[1m\u001b[1mNo implementation of function Function(<built-in function iadd>) found for signature:\n",
-      " \n",
-      " >>> iadd(Literal[int](0), array(int32, 1d, C))\n",
-      " \n",
-      "There are 18 candidate implementations:\n",
-      "\u001b[1m     - Of which 16 did not match due to:\n",
-      "     Overload of function 'iadd': File: <numerous>: Line N/A.\n",
-      "       With argument(s): '(int64, array(int32, 1d, C))':\u001b[0m\n",
-      "\u001b[1m      No match.\u001b[0m\n",
-      "\u001b[1m     - Of which 2 did not match due to:\n",
-      "     Operator Overload in function 'iadd': File: unknown: Line unknown.\n",
-      "       With argument(s): '(int64, array(int32, 1d, C))':\u001b[0m\n",
-      "\u001b[1m      No match for registered cases:\n",
-      "       * (int64, int64) -> int64\n",
-      "       * (int64, uint64) -> int64\n",
-      "       * (uint64, int64) -> int64\n",
-      "       * (uint64, uint64) -> uint64\n",
-      "       * (float32, float32) -> float32\n",
-      "       * (float64, float64) -> float64\n",
-      "       * (complex64, complex64) -> complex64\n",
-      "       * (complex128, complex128) -> complex128\u001b[0m\n",
-      "\u001b[0m\n",
-      "\u001b[0m\u001b[1mDuring: typing of intrinsic-call at /home/luna.kuleuven.be/u0166574/miniconda3/envs/crested_dev_torch/lib/python3.12/site-packages/tangermeme/tools/tomtom.py (242)\u001b[0m\n",
-      "\u001b[1m\n",
-      "File \"../../../miniconda3/envs/crested_dev_torch/lib/python3.12/site-packages/tangermeme/tools/tomtom.py\", line 242:\u001b[0m\n",
-      "\u001b[1mdef _p_values(gamma, B_cdfs, rr_inv, T_lens, nq, offset, n_bins, results):\n",
-      "    <source elided>\n",
-      "\t\t\t\t\tj, t_idx = uint64(j), uint64(total_offset + j + k)\n",
-      "\u001b[1m\t\t\t\t\tscore += gamma[j, rr_inv[t_idx]]\n",
-      "\u001b[0m     \u001b[1m^\u001b[0m\u001b[0m\n",
-      "\n",
-      "\u001b[0m\u001b[1mDuring: resolving callee type: type(CPUDispatcher(<function _p_values at 0x709694269f80>))\u001b[0m\n",
-      "\u001b[0m\u001b[1mDuring: typing of call at /home/luna.kuleuven.be/u0166574/miniconda3/envs/crested_dev_torch/lib/python3.12/site-packages/tangermeme/tools/tomtom.py (341)\n",
-      "\u001b[0m\n",
-      "\u001b[0m\u001b[1mDuring: resolving callee type: type(CPUDispatcher(<function _p_values at 0x709694269f80>))\u001b[0m\n",
-      "\u001b[0m\u001b[1mDuring: typing of call at /home/luna.kuleuven.be/u0166574/miniconda3/envs/crested_dev_torch/lib/python3.12/site-packages/tangermeme/tools/tomtom.py (341)\n",
-      "\u001b[0m\n",
-      "\u001b[1m\n",
-      "File \"../../../miniconda3/envs/crested_dev_torch/lib/python3.12/site-packages/tangermeme/tools/tomtom.py\", line 341:\u001b[0m\n",
-      "\u001b[1mdef _tomtom(Q, T, Q_lens, T_lens, Q_norm, T_norm, rr_inv, rr_counts, n_nearest, \n",
-      "    <source elided>\n",
-      "\n",
-      "\u001b[1m\t\t_p_values(_gamma[pid], _B[pid], rr_inv, T_lens, nq, offset, \n",
-      "\u001b[0m  \u001b[1m^\u001b[0m\u001b[0m\n",
-      "\n",
-      "Warning: TOMTOM error while comparing patterns Astro_pos_patterns_1 and Astro_pos_patterns_2. Returning no match.\n",
-      "Error details: Failed in nopython mode pipeline (step: nopython frontend)\n",
-      "\u001b[1m\u001b[1m\u001b[1m\u001b[1mFailed in nopython mode pipeline (step: nopython frontend)\n",
-      "\u001b[1m\u001b[1mNo implementation of function Function(<built-in function iadd>) found for signature:\n",
-      " \n",
-      " >>> iadd(Literal[int](0), array(int32, 1d, C))\n",
-      " \n",
-      "There are 18 candidate implementations:\n",
-      "\u001b[1m     - Of which 16 did not match due to:\n",
-      "     Overload of function 'iadd': File: <numerous>: Line N/A.\n",
-      "       With argument(s): '(int64, array(int32, 1d, C))':\u001b[0m\n",
-      "\u001b[1m      No match.\u001b[0m\n",
-      "\u001b[1m     - Of which 2 did not match due to:\n",
-      "     Operator Overload in function 'iadd': File: unknown: Line unknown.\n",
-      "       With argument(s): '(int64, array(int32, 1d, C))':\u001b[0m\n",
-      "\u001b[1m      No match for registered cases:\n",
-      "       * (int64, int64) -> int64\n",
-      "       * (int64, uint64) -> int64\n",
-      "       * (uint64, int64) -> int64\n",
-      "       * (uint64, uint64) -> uint64\n",
-      "       * (float32, float32) -> float32\n",
-      "       * (float64, float64) -> float64\n",
-      "       * (complex64, complex64) -> complex64\n",
-      "       * (complex128, complex128) -> complex128\u001b[0m\n",
-      "\u001b[0m\n",
-      "\u001b[0m\u001b[1mDuring: typing of intrinsic-call at /home/luna.kuleuven.be/u0166574/miniconda3/envs/crested_dev_torch/lib/python3.12/site-packages/tangermeme/tools/tomtom.py (242)\u001b[0m\n",
-      "\u001b[1m\n",
-      "File \"../../../miniconda3/envs/crested_dev_torch/lib/python3.12/site-packages/tangermeme/tools/tomtom.py\", line 242:\u001b[0m\n",
-      "\u001b[1mdef _p_values(gamma, B_cdfs, rr_inv, T_lens, nq, offset, n_bins, results):\n",
-      "    <source elided>\n",
-      "\t\t\t\t\tj, t_idx = uint64(j), uint64(total_offset + j + k)\n",
-      "\u001b[1m\t\t\t\t\tscore += gamma[j, rr_inv[t_idx]]\n",
-      "\u001b[0m     \u001b[1m^\u001b[0m\u001b[0m\n",
-      "\n",
-      "\u001b[0m\u001b[1mDuring: resolving callee type: type(CPUDispatcher(<function _p_values at 0x709694269f80>))\u001b[0m\n",
-      "\u001b[0m\u001b[1mDuring: typing of call at /home/luna.kuleuven.be/u0166574/miniconda3/envs/crested_dev_torch/lib/python3.12/site-packages/tangermeme/tools/tomtom.py (341)\n",
-      "\u001b[0m\n",
-      "\u001b[0m\u001b[1mDuring: resolving callee type: type(CPUDispatcher(<function _p_values at 0x709694269f80>))\u001b[0m\n",
-      "\u001b[0m\u001b[1mDuring: typing of call at /home/luna.kuleuven.be/u0166574/miniconda3/envs/crested_dev_torch/lib/python3.12/site-packages/tangermeme/tools/tomtom.py (341)\n",
-      "\u001b[0m\n",
-      "\u001b[1m\n",
-      "File \"../../../miniconda3/envs/crested_dev_torch/lib/python3.12/site-packages/tangermeme/tools/tomtom.py\", line 341:\u001b[0m\n",
-      "\u001b[1mdef _tomtom(Q, T, Q_lens, T_lens, Q_norm, T_norm, rr_inv, rr_counts, n_nearest, \n",
-      "    <source elided>\n",
-      "\n",
-      "\u001b[1m\t\t_p_values(_gamma[pid], _B[pid], rr_inv, T_lens, nq, offset, \n",
-      "\u001b[0m  \u001b[1m^\u001b[0m\u001b[0m\n",
-      "\n",
-      "Warning: TOMTOM error while comparing patterns Astro_pos_patterns_2 and Astro_pos_patterns_1. Returning no match.\n",
-      "Error details: Failed in nopython mode pipeline (step: nopython frontend)\n",
-      "\u001b[1m\u001b[1m\u001b[1m\u001b[1mFailed in nopython mode pipeline (step: nopython frontend)\n",
-      "\u001b[1m\u001b[1mNo implementation of function Function(<built-in function iadd>) found for signature:\n",
-      " \n",
-      " >>> iadd(Literal[int](0), array(int32, 1d, C))\n",
-      " \n",
-      "There are 18 candidate implementations:\n",
-      "\u001b[1m     - Of which 16 did not match due to:\n",
-      "     Overload of function 'iadd': File: <numerous>: Line N/A.\n",
-      "       With argument(s): '(int64, array(int32, 1d, C))':\u001b[0m\n",
-      "\u001b[1m      No match.\u001b[0m\n",
-      "\u001b[1m     - Of which 2 did not match due to:\n",
-      "     Operator Overload in function 'iadd': File: unknown: Line unknown.\n",
-      "       With argument(s): '(int64, array(int32, 1d, C))':\u001b[0m\n",
-      "\u001b[1m      No match for registered cases:\n",
-      "       * (int64, int64) -> int64\n",
-      "       * (int64, uint64) -> int64\n",
-      "       * (uint64, int64) -> int64\n",
-      "       * (uint64, uint64) -> uint64\n",
-      "       * (float32, float32) -> float32\n",
-      "       * (float64, float64) -> float64\n",
-      "       * (complex64, complex64) -> complex64\n",
-      "       * (complex128, complex128) -> complex128\u001b[0m\n",
-      "\u001b[0m\n",
-      "\u001b[0m\u001b[1mDuring: typing of intrinsic-call at /home/luna.kuleuven.be/u0166574/miniconda3/envs/crested_dev_torch/lib/python3.12/site-packages/tangermeme/tools/tomtom.py (242)\u001b[0m\n",
-      "\u001b[1m\n",
-      "File \"../../../miniconda3/envs/crested_dev_torch/lib/python3.12/site-packages/tangermeme/tools/tomtom.py\", line 242:\u001b[0m\n",
-      "\u001b[1mdef _p_values(gamma, B_cdfs, rr_inv, T_lens, nq, offset, n_bins, results):\n",
-      "    <source elided>\n",
-      "\t\t\t\t\tj, t_idx = uint64(j), uint64(total_offset + j + k)\n",
-      "\u001b[1m\t\t\t\t\tscore += gamma[j, rr_inv[t_idx]]\n",
-      "\u001b[0m     \u001b[1m^\u001b[0m\u001b[0m\n",
-      "\n",
-      "\u001b[0m\u001b[1mDuring: resolving callee type: type(CPUDispatcher(<function _p_values at 0x709694269f80>))\u001b[0m\n",
-      "\u001b[0m\u001b[1mDuring: typing of call at /home/luna.kuleuven.be/u0166574/miniconda3/envs/crested_dev_torch/lib/python3.12/site-packages/tangermeme/tools/tomtom.py (341)\n",
-      "\u001b[0m\n",
-      "\u001b[0m\u001b[1mDuring: resolving callee type: type(CPUDispatcher(<function _p_values at 0x709694269f80>))\u001b[0m\n",
-      "\u001b[0m\u001b[1mDuring: typing of call at /home/luna.kuleuven.be/u0166574/miniconda3/envs/crested_dev_torch/lib/python3.12/site-packages/tangermeme/tools/tomtom.py (341)\n",
-      "\u001b[0m\n",
-      "\u001b[1m\n",
-      "File \"../../../miniconda3/envs/crested_dev_torch/lib/python3.12/site-packages/tangermeme/tools/tomtom.py\", line 341:\u001b[0m\n",
-      "\u001b[1mdef _tomtom(Q, T, Q_lens, T_lens, Q_norm, T_norm, rr_inv, rr_counts, n_nearest, \n",
-      "    <source elided>\n",
-      "\n",
-      "\u001b[1m\t\t_p_values(_gamma[pid], _B[pid], rr_inv, T_lens, nq, offset, \n",
-      "\u001b[0m  \u001b[1m^\u001b[0m\u001b[0m\n",
-      "\n",
-      "Warning: TOMTOM error while comparing patterns Astro_pos_patterns_1 and Astro_pos_patterns_3. Returning no match.\n",
-      "Error details: Failed in nopython mode pipeline (step: nopython frontend)\n",
-      "\u001b[1m\u001b[1m\u001b[1m\u001b[1mFailed in nopython mode pipeline (step: nopython frontend)\n",
-      "\u001b[1m\u001b[1mNo implementation of function Function(<built-in function iadd>) found for signature:\n",
-      " \n",
-      " >>> iadd(Literal[int](0), array(int32, 1d, C))\n",
-      " \n",
-      "There are 18 candidate implementations:\n",
-      "\u001b[1m     - Of which 16 did not match due to:\n",
-      "     Overload of function 'iadd': File: <numerous>: Line N/A.\n",
-      "       With argument(s): '(int64, array(int32, 1d, C))':\u001b[0m\n",
-      "\u001b[1m      No match.\u001b[0m\n",
-      "\u001b[1m     - Of which 2 did not match due to:\n",
-      "     Operator Overload in function 'iadd': File: unknown: Line unknown.\n",
-      "       With argument(s): '(int64, array(int32, 1d, C))':\u001b[0m\n",
-      "\u001b[1m      No match for registered cases:\n",
-      "       * (int64, int64) -> int64\n",
-      "       * (int64, uint64) -> int64\n",
-      "       * (uint64, int64) -> int64\n",
-      "       * (uint64, uint64) -> uint64\n",
-      "       * (float32, float32) -> float32\n",
-      "       * (float64, float64) -> float64\n",
-      "       * (complex64, complex64) -> complex64\n",
-      "       * (complex128, complex128) -> complex128\u001b[0m\n",
-      "\u001b[0m\n",
-      "\u001b[0m\u001b[1mDuring: typing of intrinsic-call at /home/luna.kuleuven.be/u0166574/miniconda3/envs/crested_dev_torch/lib/python3.12/site-packages/tangermeme/tools/tomtom.py (242)\u001b[0m\n",
-      "\u001b[1m\n",
-      "File \"../../../miniconda3/envs/crested_dev_torch/lib/python3.12/site-packages/tangermeme/tools/tomtom.py\", line 242:\u001b[0m\n",
-      "\u001b[1mdef _p_values(gamma, B_cdfs, rr_inv, T_lens, nq, offset, n_bins, results):\n",
-      "    <source elided>\n",
-      "\t\t\t\t\tj, t_idx = uint64(j), uint64(total_offset + j + k)\n",
-      "\u001b[1m\t\t\t\t\tscore += gamma[j, rr_inv[t_idx]]\n",
-      "\u001b[0m     \u001b[1m^\u001b[0m\u001b[0m\n",
-      "\n",
-      "\u001b[0m\u001b[1mDuring: resolving callee type: type(CPUDispatcher(<function _p_values at 0x709694269f80>))\u001b[0m\n",
-      "\u001b[0m\u001b[1mDuring: typing of call at /home/luna.kuleuven.be/u0166574/miniconda3/envs/crested_dev_torch/lib/python3.12/site-packages/tangermeme/tools/tomtom.py (341)\n",
-      "\u001b[0m\n",
-      "\u001b[0m\u001b[1mDuring: resolving callee type: type(CPUDispatcher(<function _p_values at 0x709694269f80>))\u001b[0m\n",
-      "\u001b[0m\u001b[1mDuring: typing of call at /home/luna.kuleuven.be/u0166574/miniconda3/envs/crested_dev_torch/lib/python3.12/site-packages/tangermeme/tools/tomtom.py (341)\n",
-      "\u001b[0m\n",
-      "\u001b[1m\n",
-      "File \"../../../miniconda3/envs/crested_dev_torch/lib/python3.12/site-packages/tangermeme/tools/tomtom.py\", line 341:\u001b[0m\n",
-      "\u001b[1mdef _tomtom(Q, T, Q_lens, T_lens, Q_norm, T_norm, rr_inv, rr_counts, n_nearest, \n",
-      "    <source elided>\n",
-      "\n",
-      "\u001b[1m\t\t_p_values(_gamma[pid], _B[pid], rr_inv, T_lens, nq, offset, \n",
-      "\u001b[0m  \u001b[1m^\u001b[0m\u001b[0m\n",
-      "\n",
-      "Warning: TOMTOM error while comparing patterns Astro_pos_patterns_3 and Astro_pos_patterns_1. Returning no match.\n",
-      "Error details: Failed in nopython mode pipeline (step: nopython frontend)\n",
-      "\u001b[1m\u001b[1m\u001b[1m\u001b[1mFailed in nopython mode pipeline (step: nopython frontend)\n",
-      "\u001b[1m\u001b[1mNo implementation of function Function(<built-in function iadd>) found for signature:\n",
-      " \n",
-      " >>> iadd(Literal[int](0), array(int32, 1d, C))\n",
-      " \n",
-      "There are 18 candidate implementations:\n",
-      "\u001b[1m     - Of which 16 did not match due to:\n",
-      "     Overload of function 'iadd': File: <numerous>: Line N/A.\n",
-      "       With argument(s): '(int64, array(int32, 1d, C))':\u001b[0m\n",
-      "\u001b[1m      No match.\u001b[0m\n",
-      "\u001b[1m     - Of which 2 did not match due to:\n",
-      "     Operator Overload in function 'iadd': File: unknown: Line unknown.\n",
-      "       With argument(s): '(int64, array(int32, 1d, C))':\u001b[0m\n",
-      "\u001b[1m      No match for registered cases:\n",
-      "       * (int64, int64) -> int64\n",
-      "       * (int64, uint64) -> int64\n",
-      "       * (uint64, int64) -> int64\n",
-      "       * (uint64, uint64) -> uint64\n",
-      "       * (float32, float32) -> float32\n",
-      "       * (float64, float64) -> float64\n",
-      "       * (complex64, complex64) -> complex64\n",
-      "       * (complex128, complex128) -> complex128\u001b[0m\n",
-      "\u001b[0m\n",
-      "\u001b[0m\u001b[1mDuring: typing of intrinsic-call at /home/luna.kuleuven.be/u0166574/miniconda3/envs/crested_dev_torch/lib/python3.12/site-packages/tangermeme/tools/tomtom.py (242)\u001b[0m\n",
-      "\u001b[1m\n",
-      "File \"../../../miniconda3/envs/crested_dev_torch/lib/python3.12/site-packages/tangermeme/tools/tomtom.py\", line 242:\u001b[0m\n",
-      "\u001b[1mdef _p_values(gamma, B_cdfs, rr_inv, T_lens, nq, offset, n_bins, results):\n",
-      "    <source elided>\n",
-      "\t\t\t\t\tj, t_idx = uint64(j), uint64(total_offset + j + k)\n",
-      "\u001b[1m\t\t\t\t\tscore += gamma[j, rr_inv[t_idx]]\n",
-      "\u001b[0m     \u001b[1m^\u001b[0m\u001b[0m\n",
-      "\n",
-      "\u001b[0m\u001b[1mDuring: resolving callee type: type(CPUDispatcher(<function _p_values at 0x709694269f80>))\u001b[0m\n",
-      "\u001b[0m\u001b[1mDuring: typing of call at /home/luna.kuleuven.be/u0166574/miniconda3/envs/crested_dev_torch/lib/python3.12/site-packages/tangermeme/tools/tomtom.py (341)\n",
-      "\u001b[0m\n",
-      "\u001b[0m\u001b[1mDuring: resolving callee type: type(CPUDispatcher(<function _p_values at 0x709694269f80>))\u001b[0m\n",
-      "\u001b[0m\u001b[1mDuring: typing of call at /home/luna.kuleuven.be/u0166574/miniconda3/envs/crested_dev_torch/lib/python3.12/site-packages/tangermeme/tools/tomtom.py (341)\n",
-      "\u001b[0m\n",
-      "\u001b[1m\n",
-      "File \"../../../miniconda3/envs/crested_dev_torch/lib/python3.12/site-packages/tangermeme/tools/tomtom.py\", line 341:\u001b[0m\n",
-      "\u001b[1mdef _tomtom(Q, T, Q_lens, T_lens, Q_norm, T_norm, rr_inv, rr_counts, n_nearest, \n",
-      "    <source elided>\n",
-      "\n",
-      "\u001b[1m\t\t_p_values(_gamma[pid], _B[pid], rr_inv, T_lens, nq, offset, \n",
-      "\u001b[0m  \u001b[1m^\u001b[0m\u001b[0m\n",
-      "\n",
-      "Warning: TOMTOM error while comparing patterns Astro_pos_patterns_2 and Astro_pos_patterns_3. Returning no match.\n",
-      "Error details: Failed in nopython mode pipeline (step: nopython frontend)\n",
-      "\u001b[1m\u001b[1m\u001b[1m\u001b[1mFailed in nopython mode pipeline (step: nopython frontend)\n",
-      "\u001b[1m\u001b[1mNo implementation of function Function(<built-in function iadd>) found for signature:\n",
-      " \n",
-      " >>> iadd(Literal[int](0), array(int32, 1d, C))\n",
-      " \n",
-      "There are 18 candidate implementations:\n",
-      "\u001b[1m     - Of which 16 did not match due to:\n",
-      "     Overload of function 'iadd': File: <numerous>: Line N/A.\n",
-      "       With argument(s): '(int64, array(int32, 1d, C))':\u001b[0m\n",
-      "\u001b[1m      No match.\u001b[0m\n",
-      "\u001b[1m     - Of which 2 did not match due to:\n",
-      "     Operator Overload in function 'iadd': File: unknown: Line unknown.\n",
-      "       With argument(s): '(int64, array(int32, 1d, C))':\u001b[0m\n",
-      "\u001b[1m      No match for registered cases:\n",
-      "       * (int64, int64) -> int64\n",
-      "       * (int64, uint64) -> int64\n",
-      "       * (uint64, int64) -> int64\n",
-      "       * (uint64, uint64) -> uint64\n",
-      "       * (float32, float32) -> float32\n",
-      "       * (float64, float64) -> float64\n",
-      "       * (complex64, complex64) -> complex64\n",
-      "       * (complex128, complex128) -> complex128\u001b[0m\n",
-      "\u001b[0m\n",
-      "\u001b[0m\u001b[1mDuring: typing of intrinsic-call at /home/luna.kuleuven.be/u0166574/miniconda3/envs/crested_dev_torch/lib/python3.12/site-packages/tangermeme/tools/tomtom.py (242)\u001b[0m\n",
-      "\u001b[1m\n",
-      "File \"../../../miniconda3/envs/crested_dev_torch/lib/python3.12/site-packages/tangermeme/tools/tomtom.py\", line 242:\u001b[0m\n",
-      "\u001b[1mdef _p_values(gamma, B_cdfs, rr_inv, T_lens, nq, offset, n_bins, results):\n",
-      "    <source elided>\n",
-      "\t\t\t\t\tj, t_idx = uint64(j), uint64(total_offset + j + k)\n",
-      "\u001b[1m\t\t\t\t\tscore += gamma[j, rr_inv[t_idx]]\n",
-      "\u001b[0m     \u001b[1m^\u001b[0m\u001b[0m\n",
-      "\n",
-      "\u001b[0m\u001b[1mDuring: resolving callee type: type(CPUDispatcher(<function _p_values at 0x709694269f80>))\u001b[0m\n",
-      "\u001b[0m\u001b[1mDuring: typing of call at /home/luna.kuleuven.be/u0166574/miniconda3/envs/crested_dev_torch/lib/python3.12/site-packages/tangermeme/tools/tomtom.py (341)\n",
-      "\u001b[0m\n",
-      "\u001b[0m\u001b[1mDuring: resolving callee type: type(CPUDispatcher(<function _p_values at 0x709694269f80>))\u001b[0m\n",
-      "\u001b[0m\u001b[1mDuring: typing of call at /home/luna.kuleuven.be/u0166574/miniconda3/envs/crested_dev_torch/lib/python3.12/site-packages/tangermeme/tools/tomtom.py (341)\n",
-      "\u001b[0m\n",
-      "\u001b[1m\n",
-      "File \"../../../miniconda3/envs/crested_dev_torch/lib/python3.12/site-packages/tangermeme/tools/tomtom.py\", line 341:\u001b[0m\n",
-      "\u001b[1mdef _tomtom(Q, T, Q_lens, T_lens, Q_norm, T_norm, rr_inv, rr_counts, n_nearest, \n",
-      "    <source elided>\n",
-      "\n",
-      "\u001b[1m\t\t_p_values(_gamma[pid], _B[pid], rr_inv, T_lens, nq, offset, \n",
-      "\u001b[0m  \u001b[1m^\u001b[0m\u001b[0m\n",
-      "\n",
-      "Warning: TOMTOM error while comparing patterns Astro_pos_patterns_3 and Astro_pos_patterns_2. Returning no match.\n",
-      "Error details: Failed in nopython mode pipeline (step: nopython frontend)\n",
-      "\u001b[1m\u001b[1m\u001b[1m\u001b[1mFailed in nopython mode pipeline (step: nopython frontend)\n",
-      "\u001b[1m\u001b[1mNo implementation of function Function(<built-in function iadd>) found for signature:\n",
-      " \n",
-      " >>> iadd(Literal[int](0), array(int32, 1d, C))\n",
-      " \n",
-      "There are 18 candidate implementations:\n",
-      "\u001b[1m     - Of which 16 did not match due to:\n",
-      "     Overload of function 'iadd': File: <numerous>: Line N/A.\n",
-      "       With argument(s): '(int64, array(int32, 1d, C))':\u001b[0m\n",
-      "\u001b[1m      No match.\u001b[0m\n",
-      "\u001b[1m     - Of which 2 did not match due to:\n",
-      "     Operator Overload in function 'iadd': File: unknown: Line unknown.\n",
-      "       With argument(s): '(int64, array(int32, 1d, C))':\u001b[0m\n",
-      "\u001b[1m      No match for registered cases:\n",
-      "       * (int64, int64) -> int64\n",
-      "       * (int64, uint64) -> int64\n",
-      "       * (uint64, int64) -> int64\n",
-      "       * (uint64, uint64) -> uint64\n",
-      "       * (float32, float32) -> float32\n",
-      "       * (float64, float64) -> float64\n",
-      "       * (complex64, complex64) -> complex64\n",
-      "       * (complex128, complex128) -> complex128\u001b[0m\n",
-      "\u001b[0m\n",
-      "\u001b[0m\u001b[1mDuring: typing of intrinsic-call at /home/luna.kuleuven.be/u0166574/miniconda3/envs/crested_dev_torch/lib/python3.12/site-packages/tangermeme/tools/tomtom.py (242)\u001b[0m\n",
-      "\u001b[1m\n",
-      "File \"../../../miniconda3/envs/crested_dev_torch/lib/python3.12/site-packages/tangermeme/tools/tomtom.py\", line 242:\u001b[0m\n",
-      "\u001b[1mdef _p_values(gamma, B_cdfs, rr_inv, T_lens, nq, offset, n_bins, results):\n",
-      "    <source elided>\n",
-      "\t\t\t\t\tj, t_idx = uint64(j), uint64(total_offset + j + k)\n",
-      "\u001b[1m\t\t\t\t\tscore += gamma[j, rr_inv[t_idx]]\n",
-      "\u001b[0m     \u001b[1m^\u001b[0m\u001b[0m\n",
-      "\n",
-      "\u001b[0m\u001b[1mDuring: resolving callee type: type(CPUDispatcher(<function _p_values at 0x709694269f80>))\u001b[0m\n",
-      "\u001b[0m\u001b[1mDuring: typing of call at /home/luna.kuleuven.be/u0166574/miniconda3/envs/crested_dev_torch/lib/python3.12/site-packages/tangermeme/tools/tomtom.py (341)\n",
-      "\u001b[0m\n",
-      "\u001b[0m\u001b[1mDuring: resolving callee type: type(CPUDispatcher(<function _p_values at 0x709694269f80>))\u001b[0m\n",
-      "\u001b[0m\u001b[1mDuring: typing of call at /home/luna.kuleuven.be/u0166574/miniconda3/envs/crested_dev_torch/lib/python3.12/site-packages/tangermeme/tools/tomtom.py (341)\n",
-      "\u001b[0m\n",
-      "\u001b[1m\n",
-      "File \"../../../miniconda3/envs/crested_dev_torch/lib/python3.12/site-packages/tangermeme/tools/tomtom.py\", line 341:\u001b[0m\n",
-      "\u001b[1mdef _tomtom(Q, T, Q_lens, T_lens, Q_norm, T_norm, rr_inv, rr_counts, n_nearest, \n",
-      "    <source elided>\n",
-      "\n",
-      "\u001b[1m\t\t_p_values(_gamma[pid], _B[pid], rr_inv, T_lens, nq, offset, \n",
-      "\u001b[0m  \u001b[1m^\u001b[0m\u001b[0m\n",
-      "\n"
+      "Total iterations: 1\n"
      ]
     }
    ],
@@ -2262,15 +874,98 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 4,
    "metadata": {},
-   "outputs": [],
-   "source": []
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "(1, 11)"
+      ]
+     },
+     "execution_count": 4,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "pattern_matrix = crested.tl.modisco.create_pattern_matrix(\n",
+    "    classes=[\"Astro\"], all_patterns=all_patterns, normalize=True\n",
+    ")\n",
+    "pattern_matrix.shape"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "array([[-1.        ,  1.        ,  0.00373562,  0.65631528, -0.37076766,\n",
+       "         0.60865278,  0.38728487,  0.56011301,  0.97703065,  0.58879881,\n",
+       "         0.56519941]])"
+      ]
+     },
+     "execution_count": 5,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "pattern_matrix"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [
+    {
+     "ename": "ValueError",
+     "evalue": "The number of observations cannot be determined on an empty distance matrix.",
+     "output_type": "error",
+     "traceback": [
+      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
+      "\u001b[0;31mValueError\u001b[0m                                Traceback (most recent call last)",
+      "Cell \u001b[0;32mIn[7], line 8\u001b[0m\n\u001b[1;32m      5\u001b[0m matplotlib\u001b[38;5;241m.\u001b[39mrcParams[\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mps.fonttype\u001b[39m\u001b[38;5;124m'\u001b[39m] \u001b[38;5;241m=\u001b[39m \u001b[38;5;241m42\u001b[39m   \u001b[38;5;66;03m# For PostScript as well, if needed\u001b[39;00m\n\u001b[1;32m      7\u001b[0m pat_seqs \u001b[38;5;241m=\u001b[39m crested\u001b[38;5;241m.\u001b[39mtl\u001b[38;5;241m.\u001b[39mmodisco\u001b[38;5;241m.\u001b[39mgenerate_nucleotide_sequences(all_patterns)\n\u001b[0;32m----> 8\u001b[0m \u001b[43mcrested\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mpl\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mpatterns\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mclustermap\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m      9\u001b[0m \u001b[43m    \u001b[49m\u001b[43mpattern_matrix\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mAstro\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m]\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mAstro\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m]\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mfigsize\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m20\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m4.2\u001b[39;49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mpat_seqs\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mpat_seqs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mgrid\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43;01mTrue\u001b[39;49;00m\u001b[43m,\u001b[49m\n\u001b[1;32m     10\u001b[0m \u001b[43m)\u001b[49m\n",
+      "File \u001b[0;32m/lustre1/project/stg_00002/lcb/lmahieu/software/CREsted/src/crested/pl/patterns/_modisco_results.py:273\u001b[0m, in \u001b[0;36mclustermap\u001b[0;34m(pattern_matrix, classes, subset, figsize, grid, cmap, center, method, dy, fig_path, pat_seqs)\u001b[0m\n\u001b[1;32m    270\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m pat_seqs \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[1;32m    271\u001b[0m     plt\u001b[38;5;241m.\u001b[39mrc(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mtext\u001b[39m\u001b[38;5;124m\"\u001b[39m, usetex\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mFalse\u001b[39;00m)  \u001b[38;5;66;03m# Turn off LaTeX to speed up rendering\u001b[39;00m\n\u001b[0;32m--> 273\u001b[0m g \u001b[38;5;241m=\u001b[39m \u001b[43msns\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mclustermap\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m    274\u001b[0m \u001b[43m    \u001b[49m\u001b[43mdata\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    275\u001b[0m \u001b[43m    \u001b[49m\u001b[43mcmap\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mcmap\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    276\u001b[0m \u001b[43m    \u001b[49m\u001b[43mfigsize\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mfigsize\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    277\u001b[0m \u001b[43m    \u001b[49m\u001b[43mrow_colors\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43;01mNone\u001b[39;49;00m\u001b[43m,\u001b[49m\n\u001b[1;32m    278\u001b[0m \u001b[43m    \u001b[49m\u001b[43myticklabels\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mclasses\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    279\u001b[0m \u001b[43m    \u001b[49m\u001b[43mcenter\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mcenter\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    280\u001b[0m \u001b[43m    \u001b[49m\u001b[43mxticklabels\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43;01mTrue\u001b[39;49;00m\n\u001b[1;32m    281\u001b[0m \u001b[43m    \u001b[49m\u001b[38;5;28;43;01mif\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[43mpat_seqs\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;129;43;01mis\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[38;5;28;43;01mNone\u001b[39;49;00m\n\u001b[1;32m    282\u001b[0m \u001b[43m    \u001b[49m\u001b[38;5;28;43;01melse\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[38;5;28;43;01mFalse\u001b[39;49;00m\u001b[43m,\u001b[49m\u001b[43m  \u001b[49m\u001b[38;5;66;43;03m# Disable default xticklabels if pat_seqs provided.  #xticklabels=xtick_labels,\u001b[39;49;00m\n\u001b[1;32m    283\u001b[0m \u001b[43m    \u001b[49m\u001b[43mmethod\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mmethod\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    284\u001b[0m \u001b[43m    \u001b[49m\u001b[43mdendrogram_ratio\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m0.1\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m0.1\u001b[39;49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    285\u001b[0m \u001b[43m    \u001b[49m\u001b[43mcbar_pos\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m1.05\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m0.4\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m0.01\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m0.3\u001b[39;49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    286\u001b[0m \u001b[43m\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m    287\u001b[0m col_order \u001b[38;5;241m=\u001b[39m g\u001b[38;5;241m.\u001b[39mdendrogram_col\u001b[38;5;241m.\u001b[39mreordered_ind\n\u001b[1;32m    288\u001b[0m cbar \u001b[38;5;241m=\u001b[39m g\u001b[38;5;241m.\u001b[39max_heatmap\u001b[38;5;241m.\u001b[39mcollections[\u001b[38;5;241m0\u001b[39m]\u001b[38;5;241m.\u001b[39mcolorbar\n",
+      "File \u001b[0;32m/lustre1/project/stg_00002/mambaforge/vsc35862/envs/crested_dev_torch/lib/python3.12/site-packages/seaborn/matrix.py:1258\u001b[0m, in \u001b[0;36mclustermap\u001b[0;34m(data, pivot_kws, method, metric, z_score, standard_scale, figsize, cbar_kws, row_cluster, col_cluster, row_linkage, col_linkage, row_colors, col_colors, mask, dendrogram_ratio, colors_ratio, cbar_pos, tree_kws, **kwargs)\u001b[0m\n\u001b[1;32m   1250\u001b[0m     \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mRuntimeError\u001b[39;00m(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mclustermap requires scipy to be available\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n\u001b[1;32m   1252\u001b[0m plotter \u001b[38;5;241m=\u001b[39m ClusterGrid(data, pivot_kws\u001b[38;5;241m=\u001b[39mpivot_kws, figsize\u001b[38;5;241m=\u001b[39mfigsize,\n\u001b[1;32m   1253\u001b[0m                       row_colors\u001b[38;5;241m=\u001b[39mrow_colors, col_colors\u001b[38;5;241m=\u001b[39mcol_colors,\n\u001b[1;32m   1254\u001b[0m                       z_score\u001b[38;5;241m=\u001b[39mz_score, standard_scale\u001b[38;5;241m=\u001b[39mstandard_scale,\n\u001b[1;32m   1255\u001b[0m                       mask\u001b[38;5;241m=\u001b[39mmask, dendrogram_ratio\u001b[38;5;241m=\u001b[39mdendrogram_ratio,\n\u001b[1;32m   1256\u001b[0m                       colors_ratio\u001b[38;5;241m=\u001b[39mcolors_ratio, cbar_pos\u001b[38;5;241m=\u001b[39mcbar_pos)\n\u001b[0;32m-> 1258\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mplotter\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mplot\u001b[49m\u001b[43m(\u001b[49m\u001b[43mmetric\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mmetric\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mmethod\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mmethod\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m   1259\u001b[0m \u001b[43m                    \u001b[49m\u001b[43mcolorbar_kws\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mcbar_kws\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m   1260\u001b[0m \u001b[43m                    \u001b[49m\u001b[43mrow_cluster\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mrow_cluster\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mcol_cluster\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mcol_cluster\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m   1261\u001b[0m \u001b[43m                    \u001b[49m\u001b[43mrow_linkage\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mrow_linkage\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mcol_linkage\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mcol_linkage\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m   1262\u001b[0m \u001b[43m                    \u001b[49m\u001b[43mtree_kws\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mtree_kws\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n",
+      "File \u001b[0;32m/lustre1/project/stg_00002/mambaforge/vsc35862/envs/crested_dev_torch/lib/python3.12/site-packages/seaborn/matrix.py:1129\u001b[0m, in \u001b[0;36mClusterGrid.plot\u001b[0;34m(self, metric, method, colorbar_kws, row_cluster, col_cluster, row_linkage, col_linkage, tree_kws, **kws)\u001b[0m\n\u001b[1;32m   1125\u001b[0m     kws\u001b[38;5;241m.\u001b[39mpop(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124msquare\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n\u001b[1;32m   1127\u001b[0m colorbar_kws \u001b[38;5;241m=\u001b[39m {} \u001b[38;5;28;01mif\u001b[39;00m colorbar_kws \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m \u001b[38;5;28;01melse\u001b[39;00m colorbar_kws\n\u001b[0;32m-> 1129\u001b[0m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mplot_dendrograms\u001b[49m\u001b[43m(\u001b[49m\u001b[43mrow_cluster\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mcol_cluster\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mmetric\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mmethod\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m   1130\u001b[0m \u001b[43m                      \u001b[49m\u001b[43mrow_linkage\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mrow_linkage\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mcol_linkage\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mcol_linkage\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m   1131\u001b[0m \u001b[43m                      \u001b[49m\u001b[43mtree_kws\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mtree_kws\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m   1132\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[1;32m   1133\u001b[0m     xind \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mdendrogram_col\u001b[38;5;241m.\u001b[39mreordered_ind\n",
+      "File \u001b[0;32m/lustre1/project/stg_00002/mambaforge/vsc35862/envs/crested_dev_torch/lib/python3.12/site-packages/seaborn/matrix.py:974\u001b[0m, in \u001b[0;36mClusterGrid.plot_dendrograms\u001b[0;34m(self, row_cluster, col_cluster, metric, method, row_linkage, col_linkage, tree_kws)\u001b[0m\n\u001b[1;32m    970\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mplot_dendrograms\u001b[39m(\u001b[38;5;28mself\u001b[39m, row_cluster, col_cluster, metric, method,\n\u001b[1;32m    971\u001b[0m                      row_linkage, col_linkage, tree_kws):\n\u001b[1;32m    972\u001b[0m     \u001b[38;5;66;03m# Plot the row dendrogram\u001b[39;00m\n\u001b[1;32m    973\u001b[0m     \u001b[38;5;28;01mif\u001b[39;00m row_cluster:\n\u001b[0;32m--> 974\u001b[0m         \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mdendrogram_row \u001b[38;5;241m=\u001b[39m \u001b[43mdendrogram\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m    975\u001b[0m \u001b[43m            \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mdata2d\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mmetric\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mmetric\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mmethod\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mmethod\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mlabel\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43;01mFalse\u001b[39;49;00m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43maxis\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;241;43m0\u001b[39;49m\u001b[43m,\u001b[49m\n\u001b[1;32m    976\u001b[0m \u001b[43m            \u001b[49m\u001b[43max\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43max_row_dendrogram\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mrotate\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43;01mTrue\u001b[39;49;00m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mlinkage\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mrow_linkage\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    977\u001b[0m \u001b[43m            \u001b[49m\u001b[43mtree_kws\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mtree_kws\u001b[49m\n\u001b[1;32m    978\u001b[0m \u001b[43m        \u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m    979\u001b[0m     \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m    980\u001b[0m         \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39max_row_dendrogram\u001b[38;5;241m.\u001b[39mset_xticks([])\n",
+      "File \u001b[0;32m/lustre1/project/stg_00002/mambaforge/vsc35862/envs/crested_dev_torch/lib/python3.12/site-packages/seaborn/matrix.py:687\u001b[0m, in \u001b[0;36mdendrogram\u001b[0;34m(data, linkage, axis, label, metric, method, rotate, tree_kws, ax)\u001b[0m\n\u001b[1;32m    684\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m _no_scipy:\n\u001b[1;32m    685\u001b[0m     \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mRuntimeError\u001b[39;00m(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mdendrogram requires scipy to be installed\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n\u001b[0;32m--> 687\u001b[0m plotter \u001b[38;5;241m=\u001b[39m \u001b[43m_DendrogramPlotter\u001b[49m\u001b[43m(\u001b[49m\u001b[43mdata\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mlinkage\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mlinkage\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43maxis\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43maxis\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    688\u001b[0m \u001b[43m                             \u001b[49m\u001b[43mmetric\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mmetric\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mmethod\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mmethod\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    689\u001b[0m \u001b[43m                             \u001b[49m\u001b[43mlabel\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mlabel\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mrotate\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mrotate\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m    690\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m ax \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[1;32m    691\u001b[0m     ax \u001b[38;5;241m=\u001b[39m plt\u001b[38;5;241m.\u001b[39mgca()\n",
+      "File \u001b[0;32m/lustre1/project/stg_00002/mambaforge/vsc35862/envs/crested_dev_torch/lib/python3.12/site-packages/seaborn/matrix.py:495\u001b[0m, in \u001b[0;36m_DendrogramPlotter.__init__\u001b[0;34m(self, data, linkage, metric, method, axis, label, rotate)\u001b[0m\n\u001b[1;32m    492\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mrotate \u001b[38;5;241m=\u001b[39m rotate\n\u001b[1;32m    494\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m linkage \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[0;32m--> 495\u001b[0m     \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mlinkage \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mcalculated_linkage\u001b[49m\n\u001b[1;32m    496\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m    497\u001b[0m     \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mlinkage \u001b[38;5;241m=\u001b[39m linkage\n",
+      "File \u001b[0;32m/lustre1/project/stg_00002/mambaforge/vsc35862/envs/crested_dev_torch/lib/python3.12/site-packages/seaborn/matrix.py:562\u001b[0m, in \u001b[0;36m_DendrogramPlotter.calculated_linkage\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m    558\u001b[0m         msg \u001b[38;5;241m=\u001b[39m (\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mClustering large matrix with scipy. Installing \u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[1;32m    559\u001b[0m                \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124m`fastcluster` may give better performance.\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n\u001b[1;32m    560\u001b[0m         warnings\u001b[38;5;241m.\u001b[39mwarn(msg)\n\u001b[0;32m--> 562\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_calculate_linkage_scipy\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n",
+      "File \u001b[0;32m/lustre1/project/stg_00002/mambaforge/vsc35862/envs/crested_dev_torch/lib/python3.12/site-packages/seaborn/matrix.py:530\u001b[0m, in \u001b[0;36m_DendrogramPlotter._calculate_linkage_scipy\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m    529\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21m_calculate_linkage_scipy\u001b[39m(\u001b[38;5;28mself\u001b[39m):\n\u001b[0;32m--> 530\u001b[0m     linkage \u001b[38;5;241m=\u001b[39m \u001b[43mhierarchy\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mlinkage\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43marray\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mmethod\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mmethod\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    531\u001b[0m \u001b[43m                                \u001b[49m\u001b[43mmetric\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mmetric\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m    532\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m linkage\n",
+      "File \u001b[0;32m/lustre1/project/stg_00002/mambaforge/vsc35862/envs/crested_dev_torch/lib/python3.12/site-packages/scipy/cluster/hierarchy.py:1033\u001b[0m, in \u001b[0;36mlinkage\u001b[0;34m(y, method, metric, optimal_ordering)\u001b[0m\n\u001b[1;32m   1029\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m xp\u001b[38;5;241m.\u001b[39mall(xp\u001b[38;5;241m.\u001b[39misfinite(y)):\n\u001b[1;32m   1030\u001b[0m     \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mValueError\u001b[39;00m(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mThe condensed distance matrix must contain only \u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[1;32m   1031\u001b[0m                      \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mfinite values.\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n\u001b[0;32m-> 1033\u001b[0m n \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mint\u001b[39m(\u001b[43mdistance\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mnum_obs_y\u001b[49m\u001b[43m(\u001b[49m\u001b[43my\u001b[49m\u001b[43m)\u001b[49m)\n\u001b[1;32m   1034\u001b[0m method_code \u001b[38;5;241m=\u001b[39m _LINKAGE_METHODS[method]\n\u001b[1;32m   1036\u001b[0m y \u001b[38;5;241m=\u001b[39m np\u001b[38;5;241m.\u001b[39masarray(y)\n",
+      "File \u001b[0;32m/lustre1/project/stg_00002/mambaforge/vsc35862/envs/crested_dev_torch/lib/python3.12/site-packages/scipy/spatial/distance.py:2605\u001b[0m, in \u001b[0;36mnum_obs_y\u001b[0;34m(Y)\u001b[0m\n\u001b[1;32m   2603\u001b[0m k \u001b[38;5;241m=\u001b[39m Y\u001b[38;5;241m.\u001b[39mshape[\u001b[38;5;241m0\u001b[39m]\n\u001b[1;32m   2604\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m k \u001b[38;5;241m==\u001b[39m \u001b[38;5;241m0\u001b[39m:\n\u001b[0;32m-> 2605\u001b[0m     \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mValueError\u001b[39;00m(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mThe number of observations cannot be determined on \u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[1;32m   2606\u001b[0m                      \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124man empty distance matrix.\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n\u001b[1;32m   2607\u001b[0m d \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mint\u001b[39m(np\u001b[38;5;241m.\u001b[39mceil(np\u001b[38;5;241m.\u001b[39msqrt(k \u001b[38;5;241m*\u001b[39m \u001b[38;5;241m2\u001b[39m)))\n\u001b[1;32m   2608\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m (d \u001b[38;5;241m*\u001b[39m (d \u001b[38;5;241m-\u001b[39m \u001b[38;5;241m1\u001b[39m) \u001b[38;5;241m/\u001b[39m \u001b[38;5;241m2\u001b[39m) \u001b[38;5;241m!=\u001b[39m k:\n",
+      "\u001b[0;31mValueError\u001b[0m: The number of observations cannot be determined on an empty distance matrix."
+     ]
+    }
+   ],
+   "source": [
+    "import matplotlib\n",
+    "\n",
+    "# Set the font type to ensure text is saved as whole words\n",
+    "matplotlib.rcParams[\"pdf.fonttype\"] = 42  # Use TrueType fonts instead of Type 3 fonts\n",
+    "matplotlib.rcParams[\"ps.fonttype\"] = 42  # For PostScript as well, if needed\n",
+    "\n",
+    "pat_seqs = crested.tl.modisco.generate_nucleotide_sequences(all_patterns)\n",
+    "crested.pl.patterns.clustermap(\n",
+    "    pattern_matrix,\n",
+    "    [\"Astro\"],\n",
+    "    [\"Astro\"],\n",
+    "    figsize=(20, 4.2),\n",
+    "    pat_seqs=pat_seqs,\n",
+    "    grid=True,\n",
+    ")"
+   ]
   }
  ],
  "metadata": {
   "kernelspec": {
-   "display_name": "crested_dev",
+   "display_name": "crested_dev_torch",
    "language": "python",
    "name": "python3"
   },

From 24346d2fa45b5e3d6384403a00de02788ba9e97a Mon Sep 17 00:00:00 2001
From: LukasMahieu <lukas.mahieu@kuleuven.be>
Date: Fri, 22 Nov 2024 15:57:38 +0100
Subject: [PATCH 5/9] clustermap uses render_plot with testing

---
 .gitignore                                  |   3 +-
 src/crested/pl/patterns/_modisco_results.py |  37 ++++---
 tests/_utils.py                             | 106 ++++++++++++++++++++
 tests/test_pl.py                            |  71 +++++++++++++
 4 files changed, 203 insertions(+), 14 deletions(-)

diff --git a/.gitignore b/.gitignore
index a7df95a7..e1dac0e7 100644
--- a/.gitignore
+++ b/.gitignore
@@ -4,6 +4,7 @@ wandb/
 *slurm*
 tests/data/genomes
 tests/data/test_pipeline
+tests/data/pl_output/
 
 # Sphinx documentation
 _build
@@ -12,4 +13,4 @@ node_modules
 .DS_Store
 ._.DS_Store
 docs/tutorials/mouse_biccn.ipynb
-docs/tutorials/.ipynb_checkpoints
\ No newline at end of file
+docs/tutorials/.ipynb_checkpoints
diff --git a/src/crested/pl/patterns/_modisco_results.py b/src/crested/pl/patterns/_modisco_results.py
index 8c849a2f..b64f6193 100644
--- a/src/crested/pl/patterns/_modisco_results.py
+++ b/src/crested/pl/patterns/_modisco_results.py
@@ -63,7 +63,9 @@ def modisco_results(
     background
         Background probabilities for each nucleotide. Default is [0.27, 0.23, 0.23, 0.27].
     kwargs
-        Additional keyword arguments for the plot.
+        Additional arguments passed to :func:`~crested.pl.render_plot` to
+        control the final plot output. Please see :func:`~crested.pl.render_plot`
+        for details.
 
     See Also
     --------
@@ -196,15 +198,14 @@ def clustermap(
     pattern_matrix: np.ndarray,
     classes: list[str],
     subset: list[str] | None = None,  # Subset option
-    figsize: tuple[int, int] = (25, 8),
     grid: bool = False,
     cmap: str = "coolwarm",
     center: float = 0,
     method: str = "average",
     dy: float = 0.002,
-    fig_path: str | None = None,
     pat_seqs: list[tuple[str, np.ndarray]] | None = None,
-) -> sns.matrix.ClusterGrid:
+    **kwargs,
+) -> plt.Figure:
     """
     Create a clustermap from the given pattern matrix and class labels with customizable options.
 
@@ -232,11 +233,16 @@ def clustermap(
         Path to save the figure.
     pat_seqs
         List of sequences to use as xticklabels.
+    kwargs
+        Additional arguments passed to :func:`~crested.pl.render_plot` to
+        control the final plot output. Please see :func:`~crested.pl.render_plot`
+        for details.
 
     See Also
     --------
     crested.tl.modisco.create_pattern_matrix
     crested.tl.modisco.generate_nucleotide_sequences
+    crested.pl.render_plot
 
     Examples
     --------
@@ -245,12 +251,18 @@ def clustermap(
     ...     pattern_matrix,
     ...     classes=list(adata.obs_names)
     ...     subset=["Lamp5", "Pvalb", "Sst", "Sst-Chodl", "Vip"],
-    ...     figsize=(25, 8),
     ...     grid=True,
     ... )
 
     .. image:: ../../../../docs/_static/img/examples/pattern_clustermap.png
     """
+    default_width = 20
+    default_height = 4.2
+    if "width" not in kwargs:
+        kwargs["width"] = default_width
+    if "height" not in kwargs:
+        kwargs["height"] = default_height
+
     # Subset the pattern_matrix and classes if subset is provided
     if subset is not None:
         subset_indices = [
@@ -270,16 +282,18 @@ def clustermap(
     if pat_seqs is not None:
         plt.rc("text", usetex=False)  # Turn off LaTeX to speed up rendering
 
+    width = kwargs.get("width")
+    height = kwargs.get("height")
+    figsize = (width, height)
+
     g = sns.clustermap(
         data,
-        cmap=cmap,
         figsize=figsize,
+        cmap=cmap,
         row_colors=None,
         yticklabels=classes,
         center=center,
-        xticklabels=True
-        if pat_seqs is None
-        else False,  # Disable default xticklabels if pat_seqs provided.  #xticklabels=xtick_labels,
+        xticklabels=not pat_seqs,
         method=method,
         dendrogram_ratio=(0.1, 0.1),
         cbar_pos=(1.05, 0.4, 0.01, 0.3),
@@ -345,10 +359,7 @@ def clustermap(
 
         g.fig.canvas.draw()
 
-    if fig_path is not None:
-        plt.savefig(fig_path)
-
-    plt.show()
+    return render_plot(g.fig, **kwargs)
 
 
 def selected_instances(pattern_dict: dict, idcs: list[int]) -> None:
diff --git a/tests/_utils.py b/tests/_utils.py
index e4f5dda1..31411bc6 100644
--- a/tests/_utils.py
+++ b/tests/_utils.py
@@ -1,5 +1,7 @@
 """Utils for testing functions."""
 
+import random
+
 import anndata as ad
 import numpy as np
 import pandas as pd
@@ -29,3 +31,107 @@ def create_anndata_with_regions(
     anndata.obs_names = [f"cell_{i}" for i in range(n_classes)]
     anndata.var_names = regions
     return anndata
+
+
+def generate_simulated_patterns(
+    num_patterns=10,
+    seqlet_length=50,
+    num_instances=20,
+    seed=42,
+    cell_classes: list[str] = None,
+):
+    """Generate 'all_patterns' dict to test pattern plotting funcitons."""
+    np.random.seed(seed)
+    random.seed(seed)
+    if cell_classes is None:
+        cell_classes = [
+            "Astro",
+            "Endo",
+            "L2_3IT",
+            "L5ET",
+            "L5IT",
+            "L5_6NP",
+            "L6CT",
+            "L6IT",
+            "L6b",
+            "Micro_PVM",
+            "Oligo",
+            "Pvalb",
+            "Sst",
+            "SstChodl",
+            "VLMC",
+            "Lamp5",
+            "OPC",
+            "Sncg",
+            "Vip",
+        ]
+
+    simulated_data = {}
+    for i in range(num_patterns):
+        # Generate instances
+        instances = {}
+        for _ in range(num_instances):
+            cell_class = random.choice(cell_classes)
+            pattern_type = random.choice(["neg", "pos"])
+            pattern_index = random.randint(0, 30)
+            instance_key = f"{cell_class}_{pattern_type}_patterns_{pattern_index}"
+
+            instances[instance_key] = {
+                "sequence": np.random.dirichlet(np.ones(4), size=4),
+                "contrib_scores": np.random.randn(4, 4) * 0.01,
+                "hypothetical_contribs": np.random.randn(4, 4) * 0.01,
+                "seqlets": {
+                    "contrib_scores": np.random.randn(seqlet_length, 4, 4) * 0.01,
+                    "sequence": np.random.dirichlet(
+                        np.ones(4), size=(seqlet_length, 4)
+                    ),
+                    "class": random.choice(["Vip", "NonVip"]),
+                },
+            }
+
+        # Add data to the main pattern
+        pattern_type = random.choice(["neg", "pos"])
+        pattern_id = f"{random.choice(cell_classes)}_{pattern_type}_patterns_{random.randint(0, 30)}"
+
+        simulated_data[str(i)] = {
+            "pattern": {
+                "sequence": np.random.dirichlet(np.ones(4), size=4),
+                "contrib_scores": np.random.randn(4, 4) * 0.01,
+                "hypothetical_contribs": np.random.randn(4, 4) * 0.01,
+                "seqlets": {
+                    "contrib_scores": np.random.randn(seqlet_length, 4, 4) * 0.01,
+                    "sequence": np.random.dirichlet(
+                        np.ones(4), size=(seqlet_length, 4)
+                    ),
+                    "class": random.choice(["Vip", "NonVip"]),
+                },
+                "id": pattern_id,
+                "pos_pattern": pattern_type == "pos",
+                "ic": np.float32(np.random.uniform(0.5, 2.0)),  # Simulating ic values
+                "ppm": np.random.dirichlet(np.ones(4), size=4).astype(np.float32),
+                "class": pattern_id.split("_")[0],
+            },
+            "ic": np.random.rand(),
+            "classes": {
+                class_name: {
+                    "sequence": np.random.dirichlet(np.ones(4), size=4),
+                    "contrib_scores": np.random.randn(4, 4) * 0.01,
+                    "hypothetical_contribs": np.random.randn(4, 4) * 0.01,
+                    "seqlets": {
+                        "contrib_scores": np.random.randn(seqlet_length, 4, 4) * 0.01,
+                        "sequence": np.random.dirichlet(
+                            np.ones(4), size=(seqlet_length, 4)
+                        ),
+                        "class": random.choice(["Vip", "NonVip"]),
+                    },
+                    "id": f"{class_name}_patterns_{random.randint(0, 30)}",
+                    "pos_pattern": random.choice([True, False]),
+                    "ic": np.float32(np.random.uniform(0.5, 2.0)),
+                    "ppm": np.random.dirichlet(np.ones(4), size=4).astype(np.float32),
+                    "class": class_name,
+                }
+                for class_name in cell_classes
+            },
+            "instances": instances,
+        }
+    return simulated_data
diff --git a/tests/test_pl.py b/tests/test_pl.py
index 1b73f223..9630436b 100644
--- a/tests/test_pl.py
+++ b/tests/test_pl.py
@@ -1,10 +1,14 @@
 import inspect
+import os
+import shutil
 
 import numpy as np
 import pytest
 
 import crested.pl
 
+from ._utils import generate_simulated_patterns
+
 
 def test_plot_functions_use_render_plot():
     # Get all submodules in crested.pl
@@ -67,5 +71,72 @@ def test_locus_scoring_with_bigwig():
     assert fig is not None
 
 
+@pytest.fixture(scope="module")
+def all_patterns():
+    return generate_simulated_patterns()
+
+
+@pytest.fixture(scope="module")
+def all_classes():
+    return [
+        "Astro",
+        "Endo",
+        "L2_3IT",
+        "L5ET",
+        "L5IT",
+        "L5_6NP",
+        "L6CT",
+        "L6IT",
+        "L6b",
+        "Micro_PVM",
+        "Oligo",
+        "Pvalb",
+        "Sst",
+        "SstChodl",
+        "VLMC",
+        "Lamp5",
+        "OPC",
+        "Sncg",
+        "Vip",
+    ]
+
+
+@pytest.fixture(scope="module")
+def pattern_matrix(all_patterns, all_classes):
+    pattern_matrix = crested.tl.modisco.create_pattern_matrix(
+        classes=all_classes, all_patterns=all_patterns, normalize=True
+    )
+    return pattern_matrix
+
+
+@pytest.fixture(scope="module")
+def save_dir():
+    path = "tests/data/pl_output"
+    if os.path.exists(path):
+        shutil.rmtree(path)
+    os.makedirs(path)
+    return path
+
+
+def test_patterns_clustermap(all_patterns, all_classes, pattern_matrix, save_dir):
+    pat_seqs = crested.tl.modisco.generate_nucleotide_sequences(all_patterns)
+    save_path = os.path.join(save_dir, "patterns_clustermap.png")
+    crested.pl.patterns.clustermap(
+        pattern_matrix,
+        classes=all_classes,
+        subset=["Astro", "OPC", "Oligo"],
+        pat_seqs=pat_seqs,
+        grid=True,
+        save_path=save_path,
+        height=2,
+        width=20,
+    )
+
+
+def test_patterns_selected_instances(all_patterns, save_dir):
+    pattern_indices = [0, 1]
+    crested.pl.patterns.selected_instances(all_patterns, pattern_indices)
+
+
 if __name__ == "__main__":
     pytest.main()

From 6adc71642ecac8a28ee99c6d076d3b44e8555791 Mon Sep 17 00:00:00 2001
From: LukasMahieu <lukas.mahieu@kuleuven.be>
Date: Fri, 22 Nov 2024 16:10:48 +0100
Subject: [PATCH 6/9] selected_instances uses render_plot and tests

---
 src/crested/pl/patterns/_modisco_results.py | 20 ++++++++++++++++----
 tests/test_pl.py                            |  5 ++++-
 2 files changed, 20 insertions(+), 5 deletions(-)

diff --git a/src/crested/pl/patterns/_modisco_results.py b/src/crested/pl/patterns/_modisco_results.py
index b64f6193..c141d48a 100644
--- a/src/crested/pl/patterns/_modisco_results.py
+++ b/src/crested/pl/patterns/_modisco_results.py
@@ -362,7 +362,7 @@ def clustermap(
     return render_plot(g.fig, **kwargs)
 
 
-def selected_instances(pattern_dict: dict, idcs: list[int]) -> None:
+def selected_instances(pattern_dict: dict, idcs: list[int], **kwargs) -> None:
     """
     Plot the patterns specified by the indices in `idcs` from the `pattern_dict`.
 
@@ -373,10 +373,15 @@ def selected_instances(pattern_dict: dict, idcs: list[int]) -> None:
         contribution scores and metadata for the pattern. Refer to the output of `crested.tl.modisco.process_patterns`.
     idcs
         A list of indices specifying which patterns to plot. The indices correspond to keys in the `pattern_dict`.
+    kwargs
+        Additional arguments passed to :func:`~crested.pl.render_plot` to
+        control the final plot output. Please see :func:`~crested.pl.render_plot`
+        for details.
 
     See Also
     --------
     crested.tl.modisco.process_patterns
+    crested.pl.render_plot
 
     Examples
     --------
@@ -385,7 +390,7 @@ def selected_instances(pattern_dict: dict, idcs: list[int]) -> None:
 
     .. image:: ../../../../docs/_static/img/examples/pattern_selected_instances.png
     """
-    figure, axes = plt.subplots(nrows=len(idcs), ncols=1, figsize=(8, 2 * len(idcs)))
+    fig, axes = plt.subplots(nrows=len(idcs), ncols=1)
     if len(idcs) == 1:
         axes = [axes]
 
@@ -398,8 +403,15 @@ def selected_instances(pattern_dict: dict, idcs: list[int]) -> None:
         )
         ax.set_title(pattern_dict[str(idx)]["pattern"]["id"])
 
-    plt.tight_layout()
-    plt.show()
+    default_height = 2 * len(idcs)
+    default_width = 18
+
+    if "width" not in kwargs:
+        kwargs["width"] = default_width
+    if "height" not in kwargs:
+        kwargs["height"] = default_height
+
+    return render_plot(fig, **kwargs)
 
 
 def class_instances(
diff --git a/tests/test_pl.py b/tests/test_pl.py
index 9630436b..0f0b0579 100644
--- a/tests/test_pl.py
+++ b/tests/test_pl.py
@@ -135,7 +135,10 @@ def test_patterns_clustermap(all_patterns, all_classes, pattern_matrix, save_dir
 
 def test_patterns_selected_instances(all_patterns, save_dir):
     pattern_indices = [0, 1]
-    crested.pl.patterns.selected_instances(all_patterns, pattern_indices)
+    save_path = os.path.join(save_dir, "patterns_selected_instances.png")
+    crested.pl.patterns.selected_instances(
+        all_patterns, pattern_indices, save_path=save_path
+    )
 
 
 if __name__ == "__main__":

From f237d1c19b6f0fa9821cb08724135f88a4c4e33a Mon Sep 17 00:00:00 2001
From: LukasMahieu <lukas.mahieu@kuleuven.be>
Date: Fri, 22 Nov 2024 16:48:02 +0100
Subject: [PATCH 7/9] similarity heatmap uses render plot and testing

---
 src/crested/pl/patterns/_modisco_results.py | 64 +++++++++++++++------
 tests/test_pl.py                            | 15 +++++
 2 files changed, 60 insertions(+), 19 deletions(-)

diff --git a/src/crested/pl/patterns/_modisco_results.py b/src/crested/pl/patterns/_modisco_results.py
index c141d48a..9ad2218e 100644
--- a/src/crested/pl/patterns/_modisco_results.py
+++ b/src/crested/pl/patterns/_modisco_results.py
@@ -415,7 +415,7 @@ def selected_instances(pattern_dict: dict, idcs: list[int], **kwargs) -> None:
 
 
 def class_instances(
-    pattern_dict: dict, idx: int, class_representative: bool = False
+    pattern_dict: dict, idx: int, class_representative: bool = False, **kwargs
 ) -> None:
     """
     Plot instances of a specific pattern, either the representative pattern per class or all instances for a given pattern index.
@@ -430,10 +430,15 @@ def class_instances(
     class_representative
         If True, only the best representative instance of each class is plotted. If False (default), all instances of the pattern
         within each class are plotted.
+    kwargs
+        Additional arguments passed to :func:`~crested.pl.render_plot` to
+        control the final plot output. Please see :func:`~crested.pl.render_plot`
+        for details.
 
     See Also
     --------
     crested.tl.modisco.process_patterns
+    crested.pl.render_plot
 
     Examples
     --------
@@ -446,8 +451,9 @@ def class_instances(
     else:
         key = "instances"
     n_instances = len(pattern_dict[str(idx)][key])
-    figure, axes = plt.subplots(
-        nrows=n_instances, ncols=1, figsize=(8, 2 * n_instances)
+    fig, axes = plt.subplots(
+        nrows=n_instances,
+        ncols=1,
     )
     if n_instances == 1:
         axes = [axes]
@@ -463,15 +469,20 @@ def class_instances(
         )
         ax.set_title(pattern_dict[str(idx)][key][cl]["id"])
 
-    plt.tight_layout()
-    plt.show()
+    default_width = 8
+    default_height = 2 * n_instances
+    if "width" not in kwargs:
+        kwargs["width"] = default_width
+    if "height" not in kwargs:
+        kwargs["height"] = default_height
+
+    return render_plot(fig, **kwargs)
 
 
 def similarity_heatmap(
     similarity_matrix: np.ndarray,
     indices: list,
-    fig_size: tuple[int, int] = (30, 15),
-    fig_path: str | None = None,
+    **kwargs,
 ) -> None:
     """
     Plot a similarity heatmap of all pattern indices.
@@ -482,25 +493,26 @@ def similarity_heatmap(
         A 2D numpy array containing the similarity values.
     indices
         List of pattern indices.
-    fig_size
-        Size of the figure for the heatmap.
-    fig_path
-        Path to save the figure. If None, the figure will be shown but not saved.
+    kwargs
+        Additional arguments passed to :func:`~crested.pl.render_plot` to
+        control the final plot output. Please see :func:`~crested.pl.render_plot`
+        for details.
 
     See Also
     --------
     crested.tl.modisco.calculate_similarity_matrix
+    crested.pl.render_plot
 
     Examples
     --------
     >>> sim_matrix, indices = crested.tl.modisco.calculate_similarity_matrix(
     ...     all_patterns
     ... )
-    >>> crested.pl.patterns.similarity_heatmap(sim_matrix, indices, fig_size=(42, 17))
+    >>> crested.pl.patterns.similarity_heatmap(sim_matrix, indices, width=42, height=17))
 
     .. image:: ../../../../docs/_static/img/examples/pattern_similarity_heatmap.png
     """
-    fig, ax = plt.subplots(figsize=fig_size)
+    fig, ax = plt.subplots()
     heatmap = sns.heatmap(
         similarity_matrix,
         ax=ax,
@@ -517,13 +529,27 @@ def similarity_heatmap(
         spine.set_color("grey")
         spine.set_linewidth(0.5)
 
-    plt.title("Pattern Similarity Heatmap", fontsize=20)
-    plt.xlabel("Pattern Index", fontsize=15)
-    plt.ylabel("Pattern Index", fontsize=15)
+    default_width = 30
+    default_height = 15
 
-    if fig_path is not None:
-        plt.savefig(fig_path)
-    plt.show()
+    if "width" not in kwargs:
+        kwargs["width"] = default_width
+    if "height" not in kwargs:
+        kwargs["height"] = default_height
+    if "title" not in kwargs:
+        kwargs["title"] = "Pattern Similarity Heatmap"
+    if "xlabel" not in kwargs:
+        kwargs["xlabel"] = "Pattern Index"
+    if "ylabel" not in kwargs:
+        kwargs["ylabel"] = "Pattern Index"
+    if "title_fontsize" not in kwargs:
+        kwargs["title_fontsize"] = 20
+    if "x_label_fontsize" not in kwargs:
+        kwargs["x_label_fontsize"] = 15
+    if "y_label_fontsize" not in kwargs:
+        kwargs["y_label_fontsize"] = 15
+
+    return render_plot(fig, ax=ax, **kwargs)
 
 
 def tf_expression_per_cell_type(
diff --git a/tests/test_pl.py b/tests/test_pl.py
index 0f0b0579..b0f99c96 100644
--- a/tests/test_pl.py
+++ b/tests/test_pl.py
@@ -141,5 +141,20 @@ def test_patterns_selected_instances(all_patterns, save_dir):
     )
 
 
+def test_patterns_class_instances(all_patterns, save_dir):
+    save_path = os.path.join(save_dir, "patterns_class_instances.png")
+    crested.pl.patterns.class_instances(
+        all_patterns, idx=2, class_representative=True, save_path=save_path
+    )
+
+
+def test_patterns_similarity_heatmap(all_patterns, save_dir):
+    save_path = os.path.join(save_dir, "patterns_similarity_heatmap.png")
+    sim_matrix, indices = crested.tl.modisco.calculate_similarity_matrix(all_patterns)
+    crested.pl.patterns.similarity_heatmap(
+        sim_matrix, indices=indices, save_path=save_path
+    )
+
+
 if __name__ == "__main__":
     pytest.main()

From 6af21ced1a4a785892837da1659374985a7d75f4 Mon Sep 17 00:00:00 2001
From: LukasMahieu <lukas.mahieu@kuleuven.be>
Date: Fri, 22 Nov 2024 16:48:28 +0100
Subject: [PATCH 8/9] render_plot now accepts an axis object to be able to
 customize specific axes only

---
 src/crested/pl/_utils.py | 8 +++++++-
 1 file changed, 7 insertions(+), 1 deletion(-)

diff --git a/src/crested/pl/_utils.py b/src/crested/pl/_utils.py
index e6c3a137..3fe60fbf 100644
--- a/src/crested/pl/_utils.py
+++ b/src/crested/pl/_utils.py
@@ -7,6 +7,7 @@
 
 def render_plot(
     fig,
+    ax=None,
     width: int = 8,
     height: int = 8,
     title: str | None = None,
@@ -36,6 +37,8 @@ def render_plot(
     ----------
     fig
         The figure object to render.
+    ax
+        The axis object to which to apply the customizations. If None, all axes in the figure are modified.
     width
         Width of the plot (inches).
     height
@@ -78,7 +81,9 @@ def render_plot(
         fig.supxlabel(supxlabel)
     if supylabel:
         fig.supylabel(supylabel)
-    for ax in fig.axes:
+    axes_to_modify = [ax] if ax else fig.axes
+
+    for ax in axes_to_modify:
         if xlabel:
             ax.set_xlabel(xlabel, fontsize=x_label_fontsize)
         if ylabel:
@@ -89,6 +94,7 @@ def render_plot(
         for label in ax.get_yticklabels():
             label.set_fontsize(y_tick_fontsize)
             label.set_rotation(y_label_rotation)
+
     if tight_rect:
         plt.tight_layout(rect=tight_rect)
     else:

From 851e2e9a43d379f522397fcf7537a1a8cffa2ae7 Mon Sep 17 00:00:00 2001
From: LukasMahieu <lukas.mahieu@kuleuven.be>
Date: Fri, 22 Nov 2024 17:28:49 +0100
Subject: [PATCH 9/9] add modisco to required testing packages

---
 pyproject.toml                      | 1 +
 src/crested/pl/patterns/__init__.py | 2 +-
 2 files changed, 2 insertions(+), 1 deletion(-)

diff --git a/pyproject.toml b/pyproject.toml
index d2ccf74d..accc0c59 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -65,6 +65,7 @@ test = [
     "coverage",
     "anndata",
     "genomepy",
+    "modisco-lite",
 ]
 
 [tool.coverage.run]
diff --git a/src/crested/pl/patterns/__init__.py b/src/crested/pl/patterns/__init__.py
index de033503..e99c0513 100644
--- a/src/crested/pl/patterns/__init__.py
+++ b/src/crested/pl/patterns/__init__.py
@@ -14,7 +14,7 @@
 def _optional_function_warning(*args, **kwargs):
     logger.error(
         "The requested functionality requires the 'tfmodisco' package, which is not installed. "
-        "Please install it with `pip install crested[tfmodisco]`.",
+        "Please install it with `pip install modisco-lite`.",
     )