From 22bb4c0b990b06f4b6a83831a50a4aea8691c3fb Mon Sep 17 00:00:00 2001
From: Spencer Griswold <sgriswold@icecube.wisc.edu>
Date: Fri, 31 Oct 2025 15:55:22 -0500
Subject: [PATCH 1/2] Fixes for trigger_significance and sample_significance,
 also improving handling of xi calculation. Fixes #150

---
 python/asteria/simulation.py | 198 ++++++++++++++++-------------------
 1 file changed, 92 insertions(+), 106 deletions(-)

diff --git a/python/asteria/simulation.py b/python/asteria/simulation.py
index 87bd108..4d4e19f 100644
--- a/python/asteria/simulation.py
+++ b/python/asteria/simulation.py
@@ -812,7 +812,7 @@ def sample_significance(self, sample_size=1, dt=0.5*u.s, distance=10*u.kpc, offs
             return sample, offsets, seeds
         return sample
 
-    def trigger_significance(self, dt=0.5*u.s, binnings=[0.5, 1.5, 4, 10]*u.s, offset=0*u.s, *, seed=None):
+    def trigger_significance(self, dt=0.5 * u.s, binnings=[0.5, 1.5, 4, 10] * u.s, offset=0 * u.s, *, seed=None):
         """Simulates one SNDAQ trigger "significance" test statistic for requested binnings
 
         Parameters
@@ -853,140 +853,126 @@ def trigger_significance(self, dt=0.5*u.s, binnings=[0.5, 1.5, 4, 10]*u.s, offse
             7 - Repeat 2--5 for all binnings in `binnings`
 
         """
+        dur_sim = self.time[-1] - self.time[0]
+        if max(binnings) > dur_sim:
+            warnings.warn(f"Simulation time range ({dur_sim}) is too short "
+                          f"to generate xi using binning {max(binnings)}, unexpected behavior may occur.")
+
+        # Switches to improve readability
+        use_gen2 = self._detector_scope == 'Gen2'
+        use_gen2_wls = use_gen2 and self._add_wls
+
         _, hits_i3 = self.detector_hits(dt=dt, offset=offset, subdetector='i3')
         _, hits_dc = self.detector_hits(dt=dt, offset=offset, subdetector='dc')
-        if self._detector_scope == 'Gen2':
+
+        # Preallocate and conditionally overwrite
+        hits_md = np.zeros(hits_i3.size)
+        hits_ws = np.zeros(hits_i3.size)
+        if use_gen2:
             _, hits_md = self.detector_hits(dt=dt, offset=offset, subdetector='md')
-            if self._add_wls:
-                _, hits_ws = self.detector_hits(dt=dt, offset=offset, subdetector='ws')
+        if use_gen2_wls:
+            _, hits_ws = self.detector_hits(dt=dt, offset=offset, subdetector='ws')
 
         xi = np.zeros(binnings.size)
 
+        # Create common background to use for comparisons
+        n_bin_bg = int((600 * u.s / dt).value)  # mimics SNDAQ, i.e. 10 min for bg estimation
+        bg_i3 = self.detector.i3_bg(dt=dt, size=n_bin_bg)
+        bg_dc = self.detector.dc_bg(dt=dt, size=n_bin_bg)
+        bg_md = self.detector.md_bg(dt=dt, size=n_bin_bg) if use_gen2 else np.zeros(hits_i3.size)
+        bg_ws = self.detector.ws_bg(dt=dt, size=n_bin_bg) if use_gen2_wls else np.zeros(hits_i3.size)
+
         for idx_bin, binsize in enumerate(binnings):
             if seed is not None:
                 np.random.seed(seed)
 
             rebin_factor = int(binsize.to(u.s).value / dt.to(u.s).value)
-            n_bins = ceil(hits_i3.size/rebin_factor)
 
-            bg_i3 = self.detector.i3_bg(dt=dt, size=hits_i3.size)
-            bg_dc = self.detector.dc_bg(dt=dt, size=hits_dc.size)
-            if self._detector_scope == 'Gen2':
-                bg_md = self.detector.md_bg(dt=dt, size=hits_md.size)
-                if self._add_wls:
-                    bg_ws = self.detector.ws_bg(dt=dt, size=hits_ws.size)
+            # Compute *DOM* background rate variance in search window binsize
+            bg_i3_var_dom = rebin_factor * self.detector.i3_dom_bg(dt=dt, size=n_bin_bg).var()
+            bg_dc_var_dom = rebin_factor * self.detector.dc_dom_bg(dt=dt, size=n_bin_bg).var()
+            bg_md_var_dom = rebin_factor * self.detector.md_dom_bg(dt=dt, size=n_bin_bg).var() if use_gen2 else None
+            bg_ws_var_dom = rebin_factor * self.detector.ws_dom_bg(dt=dt, size=n_bin_bg).var() if use_gen2_wls else None
 
-            # Create a realization of background rate scaled up from dt to binsize
-            bg_i3_binned = np.zeros(n_bins)
-            bg_dc_binned = np.zeros(n_bins)
-
-            if self._detector_scope == 'Gen2':
-                bg_md_binned = np.zeros(n_bins)
-                if self._add_wls:
-                    bg_ws_binned = np.zeros(n_bins)
-                    for idx_time, (bg_i3_part, bg_dc_part, bg_md_part, bg_ws_part) in enumerate(_get_partitions(bg_i3, bg_dc, bg_md, bg_ws, part_size=rebin_factor)):
-                        bg_i3_binned[idx_time] = np.sum(bg_i3_part)
-                        bg_dc_binned[idx_time] = np.sum(bg_dc_part)
-                        bg_md_binned[idx_time] = np.sum(bg_md_part)
-                        bg_ws_binned[idx_time] = np.sum(bg_ws_part)
-                else:    
-                    for idx_time, (bg_i3_part, bg_dc_part, bg_md_part) in enumerate(_get_partitions(bg_i3, bg_dc, bg_md, part_size=rebin_factor)):
-                        bg_i3_binned[idx_time] = np.sum(bg_i3_part)
-                        bg_dc_binned[idx_time] = np.sum(bg_dc_part)
-                        bg_md_binned[idx_time] = np.sum(bg_md_part)
-            else:
-                for idx_time, (bg_i3_part, bg_dc_part) in enumerate(_get_partitions(bg_i3, bg_dc, part_size=rebin_factor)):
-                    bg_i3_binned[idx_time] = np.sum(bg_i3_part)
-                    bg_dc_binned[idx_time] = np.sum(bg_dc_part)
-
-            # Compute *DOM* background rate variance
-            # Background variance is not well estimated after the rebin, so use lower binning and upscale
-            # This could be mitigated by extending background windows, at the cost of speed
-            bg_i3_var_dom = rebin_factor * self.detector.i3_dom_bg(dt=dt, size=1000).var()
-            bg_dc_var_dom = rebin_factor * self.detector.dc_dom_bg(dt=dt, size=1000).var()
-            if self._detector_scope == 'Gen2':
-                bg_md_var_dom = rebin_factor * self.detector.md_dom_bg(dt=dt, size=1000).var()
-                if self._add_wls:
-                    bg_ws_var_dom = rebin_factor * self.detector.ws_dom_bg(dt=dt, size=1000).var()
+            # Compute *Subdetector* background rate mean in search window binsize
 
-            # If hits_i3.size / rebin_factor is not an integer, then the last bin in the rebinned rates will be partial
-            # In this case, exclude it from the calculation of the background mean
-            if bg_i3.size % rebin_factor != 0:
-                idx_bg = bg_i3_binned.size - 1
-            else:
-                idx_bg = bg_i3_binned.size
+            # If hits_i3.size % rebin_factor > 0, then rebinning will yeild a partial bin; exclude it
+            n_bins = ceil(hits_i3.size / rebin_factor)
+            if hits_i3.size % rebin_factor > 0:
+                n_bins -= 1
 
-            bg_i3_mean = bg_i3_binned[:idx_bg].mean()  # IC80 *subdetector* rate mean
-            bg_dc_mean = bg_dc_binned[:idx_bg].mean()  # DeepCore *subdetector* rate mean
-            if self._detector_scope == 'Gen2':
-                bg_md_mean = bg_md_binned[:idx_bg].mean()  # Gen2 mDOM *subdetector* rate mean
-                if self._add_wls:
-                    bg_ws_mean = bg_ws_binned[:idx_bg].mean()  # Gen2 WLS *subdetector* rate mean
-                    
-
-            ###
-            # Compute xi with increments of 0.5s offsets, mimicking the offset searches of SNDAQ
+            # Rebin background
+            bg_i3_binned = np.zeros(n_bins)
+            bg_dc_binned = np.zeros(n_bins)
+            bg_md_binned = np.zeros(n_bins)
+            bg_ws_binned = np.zeros(n_bins)
+
+            idx_parts = [p for p in _get_partitions(np.arange(hits_i3.size), part_size=rebin_factor)][:n_bins]
+            for idx_time, idx_part in enumerate(idx_parts):
+                bg_i3_binned[idx_time] = bg_i3[idx_part].sum()
+                bg_dc_binned[idx_time] = bg_dc[idx_part].sum()
+                bg_md_binned[idx_time] = bg_md[idx_part].sum()
+                bg_ws_binned[idx_time] = bg_ws[idx_part].sum()
+
+            bg_i3_mean = bg_i3_binned.mean()
+            bg_dc_mean = bg_dc_binned.mean()
+            bg_md_mean = bg_md_binned.mean() if use_gen2 else 0
+            bg_ws_mean = bg_ws_binned.mean() if use_gen2_wls else 0
+
+            # Compute var_dmu, which depends on only background estimation (later used in xi calc)
+            # Compute as 1 / var_dmu, to streamline sums, then invert to obtain var_dmu
+            inv_var_dmu = ((self.detector.n_i3_doms / bg_i3_var_dom) +
+                           (self.detector.n_dc_doms * self.detector.dc_rel_eff ** 2 / bg_dc_var_dom))
+            inv_var_dmu += self.detector.n_md / bg_md_var_dom if use_gen2 else 0
+            inv_var_dmu += self.detector.n_ws * self.detector.ws_rel_eff ** 2 / bg_ws_var_dom if use_gen2_wls else 0
+            # TODO Jakob: Is rel. efficiency factor needed here or is it implicitly included?
+            var_dmu = 1 / inv_var_dmu
+
+            # Apply offsets to signal to mimic SNDAQ offset searches
             for idx_offset in range(rebin_factor):
                 hits_i3_offset = np.roll(hits_i3, idx_offset)
                 hits_i3_offset[:idx_offset] = 0
-                hits_i3_binned = np.zeros(n_bins)
 
                 hits_dc_offset = np.roll(hits_dc, idx_offset)
                 hits_dc_offset[:idx_offset] = 0
-                hits_dc_binned = np.zeros(n_bins)
 
-                if self._detector_scope == "Gen2":
+                # Define and conditionally overwrite
+                hits_md_offset = np.zeros(hits_i3.size)
+                hits_ws_offset = np.zeros(hits_i3.size)
+                if use_gen2:
                     hits_md_offset = np.roll(hits_md, idx_offset)
                     hits_md_offset[:idx_offset] = 0
-                    hits_md_binned = np.zeros(n_bins)
 
-                    if self._add_wls:
-                        hits_ws_offset = np.roll(hits_ws, idx_offset)
-                        hits_ws_offset[:idx_offset] = 0
-                        hits_ws_binned = np.zeros(n_bins)
-                
-                        for idx_time, (hits_i3_part, hits_dc_part, hits_md_part, hits_ws_part) in enumerate(_get_partitions(hits_i3_offset, hits_dc_offset,
-                                                                                                hits_md_offset, hits_ws_offset, part_size=rebin_factor)):
-                            hits_i3_binned[idx_time] = np.sum(hits_i3_part)
-                            hits_dc_binned[idx_time] = np.sum(hits_dc_part)
-                            hits_md_binned[idx_time] = np.sum(hits_md_part)
-                            hits_ws_binned[idx_time] = np.sum(hits_ws_part)
-
-                        var_dmu = 1/((self.detector.n_i3_doms/bg_i3_var_dom) +
-                                    (self.detector.n_dc_doms*self.detector.dc_rel_eff**2/bg_dc_var_dom) + 
-                                    (self.detector.n_md/bg_md_var_dom) + 
-                                    (self.detector.n_ws*self.detector.ws_rel_eff**2/bg_ws_var_dom)) # TODO Jakob: Is rel. efficiency factor needed here or is it implicitly included?
-                        dmu = var_dmu * (
-                                ((hits_i3_binned + bg_i3_binned - bg_i3_mean) / bg_i3_var_dom) +
-                                ((hits_dc_binned + bg_dc_binned - bg_dc_mean) / bg_dc_var_dom) +
-                                ((hits_md_binned + bg_md_binned - bg_md_mean) / bg_md_var_dom) + 
-                                ((hits_ws_binned + bg_ws_binned - bg_ws_mean) / bg_ws_var_dom))
-                        _xi = dmu/np.sqrt(var_dmu)
-
-                        xi[idx_bin] = np.max([xi[idx_bin], _xi.max()])
-
-                        return xi
-                    
-                    else:
+                if use_gen2_wls:
+                    hits_ws_offset = np.roll(hits_ws, idx_offset)
+                    hits_ws_offset[:idx_offset] = 0
+
+                # Rebin hits post-offset
+                hits_i3_binned = np.zeros(n_bins)
+                hits_dc_binned = np.zeros(n_bins)
+                hits_md_binned = np.zeros(n_bins)
+                hits_ws_binned = np.zeros(n_bins)
+
+                for idx_time, idx_part in enumerate(idx_parts):
+                    hits_i3_binned[idx_time] = np.sum(hits_i3_offset[idx_part])
+                    hits_dc_binned[idx_time] = np.sum(hits_dc_offset[idx_part])
+                    hits_md_binned[idx_time] = np.sum(hits_md_offset[idx_part])
+                    hits_ws_binned[idx_time] = np.sum(hits_ws_offset[idx_part])
+
+                # Compute xi
+                dmu = var_dmu * (
+                        ((hits_i3_binned + bg_i3_binned - bg_i3_mean) / bg_i3_var_dom) +
+                        ((hits_dc_binned + bg_dc_binned - bg_dc_mean) / bg_dc_var_dom))
+                dmu += var_dmu * ((hits_md_binned + bg_md_binned - bg_md_mean) / bg_md_var_dom) if use_gen2 else 0
+                dmu += var_dmu * ((hits_ws_binned + bg_ws_binned - bg_ws_mean) / bg_ws_var_dom) if use_gen2_wls else 0
 
-                        for idx_time, (hits_i3_part, hits_dc_part, hits_md_part) in enumerate(_get_partitions(hits_i3_offset, hits_dc_offset,
-                                                                                                hits_md_offset, part_size=rebin_factor)):
-                            hits_i3_binned[idx_time] = np.sum(hits_i3_part)
-                            hits_dc_binned[idx_time] = np.sum(hits_dc_part)
-                            hits_md_binned[idx_time] = np.sum(hits_md_part)
+                _xi = dmu / np.sqrt(var_dmu)
 
-                        var_dmu = 1/((self.detector.n_i3_doms/bg_i3_var_dom) +
-                                    (self.detector.n_dc_doms*self.detector.dc_rel_eff**2/bg_dc_var_dom) + 
-                                    (self.detector.n_md/bg_md_var_dom))
-                        dmu = var_dmu * (
-                                ((hits_i3_binned + bg_i3_binned - bg_i3_mean) / bg_i3_var_dom) +
-                                ((hits_dc_binned + bg_dc_binned - bg_dc_mean) / bg_dc_var_dom) +
-                                ((hits_md_binned + bg_md_binned - bg_md_mean) / bg_md_var_dom))
-                        _xi = dmu/np.sqrt(var_dmu)
+                # Update xi in current binning if offset window provides better xi
+                xi[idx_bin] = np.max([xi[idx_bin], _xi.max()])
 
-                        xi[idx_bin] = np.max([xi[idx_bin], _xi.max()])
+        return xi
 
-                        return xi
               
 def _get_partitions(*args, part_size=1000):
     if len(args) > 1:

From 66c4bd5ad0019cb9adafa3f72be521f86908998f Mon Sep 17 00:00:00 2001
From: Spencer Griswold <sgriswold@icecube.wisc.edu>
Date: Fri, 31 Oct 2025 16:00:13 -0500
Subject: [PATCH 2/2] Add example notebook for significance functions

---
 .../nb/sample_significance_example.ipynb      | 326 ++++++++++++++++++
 1 file changed, 326 insertions(+)
 create mode 100644 docs/source/nb/sample_significance_example.ipynb

diff --git a/docs/source/nb/sample_significance_example.ipynb b/docs/source/nb/sample_significance_example.ipynb
new file mode 100644
index 0000000..5b59a15
--- /dev/null
+++ b/docs/source/nb/sample_significance_example.ipynb
@@ -0,0 +1,326 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "65f4a077-3f90-450a-a8dc-e63706bd689b",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from astropy import units as u\n",
+    "\n",
+    "import numpy as np\n",
+    "import matplotlib as mpl\n",
+    "import matplotlib.pyplot as plt\n",
+    "\n",
+    "from snewpy.models.ccsn import Nakazato_2013\n",
+    "\n",
+    "from asteria.simulation import Simulation\n",
+    "from asteria import set_rcparams\n",
+    "from asteria import interactions\n",
+    "\n",
+    "set_rcparams(verbose=False)\n",
+    "%matplotlib inline"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "84b65ba5-613e-4521-a7f0-7715238dcb30",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/markdown": [
+       "**Nakazato_2013 Model**: nakazato-shen-z0.02-t_rev300ms-s13.0.fits\n",
+       "\n",
+       "|Parameter|Value|\n",
+       "|:--------|:----:|\n",
+       "|Progenitor mass | $13$ $\\mathrm{M_{\\odot}}$|\n",
+       "|Revival time | $300$ $\\mathrm{ms}$|\n",
+       "|Metallicity | 0.02 |\n",
+       "|EOS | shen |"
+      ],
+      "text/plain": [
+       "Nakazato_2013 Model: nakazato-shen-z0.02-t_rev300ms-s13.0.fits\n",
+       "Progenitor mass  : 13.0 solMass\n",
+       "Revival time     : 300.0 ms\n",
+       "Metallicity      : 0.02\n",
+       "EOS              : shen"
+      ]
+     },
+     "execution_count": 2,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# Model used for SN Firedrills in 2023\n",
+    "param  = {\n",
+    "    \"progenitor_mass\": 13 * u.Msun,\n",
+    "    \"revival_time\": 300 * u.ms,\n",
+    "    \"metallicity\": 0.02,\n",
+    "    \"eos\": \"shen\"\n",
+    "}\n",
+    "model = {\n",
+    "    \"name\": \"Nakazato_2013\",\n",
+    "    \"param\": param\n",
+    "}\n",
+    "Nakazato_2013(**param)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "28df179d-bf51-40fe-a442-8ceb38b501bb",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "sim = Simulation(model=model,\n",
+    "                 distance=10 * u.kpc,\n",
+    "                 Emin=0 * u.MeV, Emax=100 * u.MeV, dE=1 * u.MeV,\n",
+    "                 tmin=-10 * u.s, tmax= 30 * u.s, dt=1 * u.ms, \n",
+    "                )\n",
+    "sim.run()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "c5307de0-5e8b-455a-8493-b92f4d821fe9",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Utility for printing results neatly, assumes, sample_significance argument only_highest=False\n",
+    "base_bin_size = 0.5 * u.s\n",
+    "bin_sizes = [0.5, 1.5, 4, 10] * u.s\n",
+    "\n",
+    "def print_sample(s, *, end=\"\\n\"):\n",
+    "    if isinstance(s[0], float):\n",
+    "        s = [s,]\n",
+    "        \n",
+    "    base_fmt = \"{{0:{fmt}}} | {{1:{fmt}}} | {{2:{fmt}}} | {{3:{fmt}}}\"\n",
+    "    row_fmt = base_fmt.format(fmt=\">7.2f\")\n",
+    "    hdr_fmt = base_fmt.format(fmt=\"^7s\")\n",
+    "    \n",
+    "    hdr = hdr_fmt.format(*[str(b) for b in bin_sizes])\n",
+    "    div = len(hdr) * \"-\"\n",
+    "    rows = [row_fmt.format(*row) for row in s]\n",
+    "    table = \"\\n\".join([hdr, div, *rows])\n",
+    "\n",
+    "    print(table, end=end)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "de69a4c1-ac95-4a66-bd9b-a8ea64479a8e",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 0.5 s  |  1.5 s  |  4.0 s  | 10.0 s \n",
+      "-------------------------------------\n",
+      " 249.04 |  158.62 |  106.51 |   73.35\n",
+      "\n",
+      "\n",
+      " 0.5 s  |  1.5 s  |  4.0 s  | 10.0 s \n",
+      "-------------------------------------\n",
+      " 224.31 |  154.11 |  104.97 |   72.80\n",
+      " 205.02 |  153.86 |  104.21 |   74.26\n",
+      " 134.53 |  153.57 |  105.26 |   74.20\n",
+      " 154.36 |  156.19 |  110.91 |   76.77\n",
+      " 227.09 |  152.64 |  104.51 |   72.66\n",
+      " 186.55 |  161.08 |  110.88 |   77.20\n",
+      " 240.87 |  156.16 |  107.30 |   74.67\n",
+      " 246.62 |  160.03 |  108.27 |   75.97\n",
+      " 198.16 |  152.33 |  106.12 |   73.69\n",
+      " 239.38 |  156.19 |  107.08 |   74.76\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Estimated background characteristics for run 127138 (used for FD, obtained with PySNDAQ)\n",
+    "sim.detector.set_i3_background(mu = 289.436, sig = 20.723)\n",
+    "sim.detector.set_dc_background(mu = 377.480, sig = 23.040)\n",
+    "\n",
+    "xi = sim.trigger_significance(base_bin_size, binnings=bin_sizes)\n",
+    "print_sample(xi, end=3*\"\\n\")\n",
+    "\n",
+    "sample = sim.sample_significance(10, dt=base_bin_size, binnings=bin_sizes, only_highest=False)\n",
+    "print_sample(sample)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "9a6bce08-1f5c-4432-ac49-6e437e53fe4a",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "xi = 203.72 +- 33.53 (sample)\n",
+      "xi = 193.36 +- 13.91 (arXiv:2308.01843, 2023)\n",
+      "xi_FD = 204.15\n"
+     ]
+    }
+   ],
+   "source": [
+    "sample = sim.sample_significance(100, dt=base_bin_size, binnings=bin_sizes, only_highest=True)\n",
+    "print(f\"xi = {f'{sample.mean():>.2f} +- {sample.std():<.2f}'} (sample)\")\n",
+    "print(f\"xi = 193.36 +- 13.91 (arXiv:2308.01843, 2023)\")\n",
+    "print(f\"xi_FD = 204.15\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "aff3b7eb-3360-483d-a313-5ac0c5ca80d8",
+   "metadata": {},
+   "source": [
+    "See [https://arxiv.org/abs/2308.01843](arXiv:2308.01843) for more information on Firedrill (FD) expectation. Note, ASTERIA, SNEWPY, and SNDAQ have received multiple updates since this proceeding, and the parameters of the FD simulation may not be perfectly matched by this notebook. "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "63e9f8a1-5cb9-4776-b9eb-b1f12bccb3db",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 800x600 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "dt = 2 * u.ms\n",
+    "t, hits_i3 = sim.detector_hits(subdetector='i3', dt=dt)\n",
+    "t, hits_dc = sim.detector_hits(subdetector='dc', dt=dt)\n",
+    "\n",
+    "fig, ax = plt.subplots(1,1, figsize=(8,6), tight_layout=True)\n",
+    "ax.plot(t, hits_i3, label='IceCube DOM')\n",
+    "ax.plot(t, hits_dc, label='HQE DOM (DeepCore)')\n",
+    "ax.legend()\n",
+    "ax.set(xlabel=r'$t-t_\\mathrm{bounce}$ [s]',\n",
+    "       ylabel=f'Subdetector Rate (Signal Only) [Hz]',\n",
+    "       xlim=(-0.5, 7.5));"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "id": "9cda01ba-4634-4971-8e97-515bede17f3e",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "sim = Simulation(model=model,\n",
+    "                 distance=10 * u.kpc,\n",
+    "                 Emin=0 * u.MeV, Emax=100 * u.MeV, dE=1 * u.MeV,\n",
+    "                 tmin=-10 * u.s, tmax= 30 * u.s, dt=1 * u.ms,\n",
+    "                 detector_scope=\"Gen2\")\n",
+    "sim.run()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "id": "a599b090-2fea-4f7e-8bd2-6463fd0feb97",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " 0.5 s  |  1.5 s  |  4.0 s  | 10.0 s \n",
+      "-------------------------------------\n",
+      " 307.45 |  194.67 |  128.60 |   90.38\n",
+      "\n",
+      "\n",
+      " 0.5 s  |  1.5 s  |  4.0 s  | 10.0 s \n",
+      "-------------------------------------\n",
+      " 294.30 |  195.09 |  134.12 |   93.53\n",
+      " 203.30 |  189.64 |  130.66 |   90.10\n",
+      " 272.77 |  197.89 |  136.05 |   94.94\n",
+      " 300.28 |  194.29 |  134.22 |   94.16\n",
+      " 274.23 |  185.99 |  128.29 |   90.37\n",
+      " 292.86 |  191.17 |  132.13 |   91.51\n",
+      " 254.96 |  196.15 |  134.86 |   94.96\n",
+      " 301.43 |  196.06 |  134.53 |   93.50\n",
+      " 173.08 |  192.88 |  134.04 |   92.99\n",
+      " 160.41 |  194.43 |  132.24 |   91.88\n"
+     ]
+    }
+   ],
+   "source": [
+    "xi = sim.trigger_significance(base_bin_size, binnings=bin_sizes)\n",
+    "print_sample(xi, end=3*\"\\n\")\n",
+    "\n",
+    "sample = sim.sample_significance(10, dt=base_bin_size, binnings=bin_sizes, only_highest=False)\n",
+    "print_sample(sample)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "id": "fca5904f-8755-4196-9e6e-67ccc5dcad5d",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 800x600 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "dt = 2 * u.ms\n",
+    "t, hits_i3 = sim.detector_hits(subdetector='i3', dt=dt)\n",
+    "t, hits_dc = sim.detector_hits(subdetector='dc', dt=dt)\n",
+    "t, hits_md = sim.detector_hits(subdetector='md', dt=dt)\n",
+    "\n",
+    "fig, ax = plt.subplots(1,1, figsize=(8,6), tight_layout=True)\n",
+    "ax.plot(t, hits_i3, label='IceCube DOM')\n",
+    "ax.plot(t, hits_dc, label='HQE DOM (DeepCore)')\n",
+    "ax.plot(t, hits_md, label='mDOMs (Gen2)')\n",
+    "ax.legend()\n",
+    "ax.set(xlabel=r'$t-t_\\mathrm{bounce}$ [s]',\n",
+    "       ylabel=f'Subdetector Rate (Signal Only) [Hz]',\n",
+    "       xlim=(-2.5, 5));"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "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.13.5"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}