README.md

---
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 |
| `cellid_positions.npz` | 6.2 MB | sensor geometry lookup: `cellids` (sorted uint64) → `xyz` (float32, mm) for all 322,560 real dRICH sensor pixels. Needed to resolve raw `cellID` values (from `hits_t.tar.gz`, or from a fresh simulation) into physical hit positions |

### `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 is
   `cellid_positions.npz`, included in this repo.
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),
including a `predict_from_root.py` script that runs the model directly
on a raw simulation `.root` file using this repo's `cellid_positions.npz`.