Datasets:

deepaksamuel-cuk
/

simhits

 ---
+license: unknown
+tags:
+- physics
+- particle-physics
+- high-energy-physics
+- detector-simulation
+- cherenkov
+- eic
+- drich
 ---
+# dRICH simulated hit data (bljul21 baseline)
+Real, non-synthetic simulated photon-hit data from the EPIC dRICH detector
+(the dual-radiator RICH — aerogel + gas — of the EIC's EPIC experiment),
+for 4 charged-particle species. This is the exact data used to train and
+evaluate a Vision-Transformer particle-ID baseline (**ViT-BL**).
+**No injected noise, no synthetic mixing, no QE (quantum-efficiency) hit
+loss, no pixel-gap simulation, no augmentation of any kind, at any
+stage** (generation, training, or testing). Every hit in every file here
+is a real simulated photon hit.
+## Files in this repo
+| file | size | contents |
+|---|---|---|
+| `dataset.npz` | 18 MB | per-event metadata for all 600,020 events |
+| `hits_xy.npy` | 1.70 GB | every photon hit's (x, y) sensor-plane position [mm], all events concatenated |
+| `hits_t.tar.gz` | 1.39 GB | the raw per-event source: 600,020 individual `hits_{PID}_{MOM}_{ETA}_{PHI}.npz` files, each with `cellID` (uint64) + `time` (float32, ns), before cellID was resolved to a physical position |
+### `dataset.npz` fields
+| key | dtype / shape | meaning |
+|---|---|---|
+| `label` | int8, (600020,) | 0=electron, 1=pion, 2=kaon, 3=proton |
+| `mom` | float32, (600020,) | generated momentum [GeV/c] |
+| `eta` | float32, (600020,) | generated pseudorapidity |
+| `phi` | float32, (600020,) | generated azimuth [rad] |
+| `center` | float32, (600020,2) | per-event median hit (x,y) [mm] (only used for zoomed/crop visualizations) |
+| `offsets` | int64, (600021,) | `hits_xy[offsets[j]:offsets[j+1]]` = event `j`'s hits |
+| `split` | int8, (600020,) | 0=train, 1=val, 2=test (80/10/10, split independently per species) |
+`hits_xy.npy` contains **all** splits together, undivided — train, val,
+and test hits all live in the same array; only `dataset.npz['split']`
+tells you which is which.
+## Particle ID convention
+Standard PDG codes: `11`=electron, `211`=pion(+), `321`=kaon(+),
+`2212`=proton. Filenames (and the raw `hits_t.tar.gz` contents) follow
+`{PID}_{MOM}_{ETA}_{PHI}` — momentum in GeV/c, eta as generated, phi in
+radians.
+## Generated kinematic ranges
+- momentum: 0.5–60.5 GeV/c, in 0.1 GeV/c steps (601 grid values)
+- eta: 1.5–3.5, in 0.1 steps (21 grid values)
+- phi: 0–2π, in 0.1 rad steps (63 grid values)
+Each species independently randomly sampled ~150,000 (p, eta, phi)
+triples from that ~795,000-point grid — this is **not** a shared grid
+reused across species; any overlap between species' kinematic points is
+coincidental (matches the ~19% overlap expected from independent random
+sampling from the same grid).
+## Aerogel Cherenkov threshold (n = 1.026)
+`p_thr = mass / sqrt(n^2 - 1)`. Used to define the "above threshold"
+(ATH) vs "below threshold" (BTH) splits in the companion ViT-BL baseline.
+| species | mass [GeV] | p_thr [GeV/c] |
+|---|---|---|
+| electron | 0.000511 | 0.0022 |
+| pion | 0.139570 | 0.6081 |
+| kaon | 0.493677 | 2.1510 |
+| proton | 0.938272 | 4.0881 |
+## How this data was created
+1. **hepmc generation** — one single-event hepmc file per (PID, momentum,
+   eta, phi) combination, covering the full grid above.
+2. **Geant4 simulation** — each hepmc file run through the EPIC detector
+   simulation (`drich-dev/simulate.py`), one event per output file.
+3. **Extraction** — `DRICHHits/cellID` and `DRICHHits/time` pulled from
+   each simulation ROOT file (`uproot` + `awkward`), one `.npz` per event
+   containing the raw `cellID`/`time` arrays — this is `hits_t.tar.gz`.
+   The raw simulation ROOT files were deleted immediately after
+   extraction to save disk space (not recoverable — only the extracted
+   hits remain).
+4. **Geometry resolution** — every unique `cellID` resolved to a global
+   (x, y, z) mm position via `dd4hep`'s `CellIDPositionConverter`, run
+   against the real EPIC/dRICH detector geometry. This lookup table
+   (`cellid_positions.npz`) is geometry-specific and not included in this
+   repo; regenerate it from the EPIC compact detector XML if needed.
+5. **Consolidation** — all 600,020 events' hits (now resolved to x,y)
+   concatenated into `hits_xy.npy`, with per-event metadata gathered into
+   `dataset.npz`.
+## Quick start: load an event's hits
+```python
+import numpy as np
+from huggingface_hub import hf_hub_download
+REPO = "deepaksamuel-cuk/simhits"
+dataset_path = hf_hub_download(REPO, "dataset.npz", repo_type="dataset")
+hits_path = hf_hub_download(REPO, "hits_xy.npy", repo_type="dataset")
+d = np.load(dataset_path)
+label, mom, eta, phi, offsets = d["label"], d["mom"], d["eta"], d["phi"], d["offsets"]
+hits = np.load(hits_path, mmap_mode="r")  # ~1.6 GiB -- mmap avoids loading it all into RAM
+j = 0  # any event index, 0 <= j < 600020
+a, b = offsets[j], offsets[j + 1]
+pts = np.asarray(hits[a:b], dtype=np.float32)  # this event's (x, y) hit positions [mm]
+print(label[j], mom[j], eta[j], phi[j], len(pts), "hits")
+```
+## Rasterizing into a training-style image
+Pixel value = `log1p(hit count)` — cells with more hits get more weight
+(brighter), full detector extent (384x384 px over a 3540 mm window,
+matching the real dRICH sensor plane's physical size). Multiple hits
+landing in the same sensor cell are **summed**, not overwritten or
+capped — `np.add.at` is used specifically because it correctly
+accumulates duplicate indices, unlike plain indexed assignment.
+```python
+FULL_IMG, FULL_WINDOW = 384, 3540.0
+def rasterize(pts, img_size=FULL_IMG, window=FULL_WINDOW):
+    img = np.zeros((img_size, img_size), dtype=np.float32)
+    if len(pts) == 0:
+        return img
+    rel = (pts - (-window / 2)) * (img_size / window)
+    ij = np.floor(rel).astype(np.int64)
+    ok = (ij[:, 0] >= 0) & (ij[:, 0] < img_size) & (ij[:, 1] >= 0) & (ij[:, 1] < img_size)
+    ij = ij[ok]
+    np.add.at(img, (ij[:, 1], ij[:, 0]), 1.0)  # accumulate, never overwrite
+    return np.log1p(img)
+img = rasterize(pts)  # (384, 384) float32, ready to imshow() or feed to a model
+```
+## Ready-to-run code in this repo
+- **`view_hits.py`** — command-line script. Pick a PID/momentum/eta/phi,
+  it finds the closest real matching event (the grid above means your
+  exact input almost never exists as an event) and saves a PNG of the
+  rasterized hit image:
+  ```bash
+  python view_hits.py --pid 2212 --mom 30 --eta 2.0 --phi 3.14 --out proton.png
+  ```
+- **`colab_hit_viewer.ipynb`** — the same lookup, as an interactive
+  Colab notebook (dropdown + text fields, live plotly plot). Upload it
+  to https://colab.research.google.com directly.
+## Related model
+A ViT-BL baseline model (Vision Transformer, trained from scratch, no
+ImageNet pretraining) trained on this data's above-threshold events is
+published separately at
+[deepaksamuel-cuk/drich-vit-baseline](https://huggingface.co/deepaksamuel-cuk/drich-vit-baseline).