| """Pass 2: duplicate clusters, one bucket per worker. |
| |
| Within each exact-composition group (all subsets together), triplets are taken in ms_id order and leader-clustered: |
| a triplet joins the first cluster whose representative has |
| * a cell within 2 % on every length and 1 degree on every angle, |
| * a saddle within 0.2 A max-atom distance, and |
| * both endpoints within 0.2 A max-atom, in the same or the swapped (R<->P) orientation; |
| otherwise it founds a new cluster. Distances: species-wise Hungarian assignment (min summed squared distance) under the |
| minimum-image convention, fractional coordinates mapped into the mean of the two cells. The representative (kept |
| triplet) of every cluster is its lowest ms_id. |
| Writes clusters/b<NN>.npz: ms, rep (representative ms of its cluster), and per-bucket counters. |
| usage: dedup_pass2.py [workers] [threshold_A] |
| """ |
| import glob, os, sys, time |
| import numpy as np |
| from collections import defaultdict |
| from multiprocessing import Pool |
| from scipy.optimize import linear_sum_assignment |
|
|
| OUT = "/scratch/08405/ilgar/saddleflow/data/dedup_2026-09-28"; NB = 64 |
| THR = float(sys.argv[2]) if len(sys.argv) > 2 else 0.2 |
|
|
|
|
| def cellpar(c): |
| a, b, g = c |
| L = np.linalg.norm(c, axis=1) |
| ang = lambda u, v: np.degrees(np.arccos(np.clip(u @ v / np.linalg.norm(u) / np.linalg.norm(v), -1, 1))) |
| return np.array([L[0], L[1], L[2], ang(b, g), ang(a, g), ang(a, b)]) |
|
|
|
|
| def maxd(p1, c1, p2, c2, z, species, stop): |
| """max-atom distance; returns early (> stop) as soon as one species exceeds `stop`.""" |
| periodic = abs(np.linalg.det(c1)) > 1e-6 and abs(np.linalg.det(c2)) > 1e-6 |
| if periodic: |
| cm = 0.5 * (c1 + c2); inv = np.linalg.inv(cm) |
| q1 = (p1 @ np.linalg.inv(c1)) @ cm; q2 = (p2 @ np.linalg.inv(c2)) @ cm |
| else: |
| q1, q2 = p1.astype(float), p2.astype(float) |
| mx = 0.0 |
| for idx in species: |
| dv = (q1[idx][:, None, :] - q2[idx][None, :, :]).reshape(-1, 3) |
| if periodic: |
| f = dv @ inv; f -= np.round(f); dv = f @ cm |
| d2 = (dv.reshape(len(idx), len(idx), 3) ** 2).sum(2) |
| r, k = linear_sum_assignment(d2); m = float(np.sqrt(d2[r, k].max())) |
| if m > mx: |
| mx = m |
| if mx >= stop: return mx |
| return mx |
|
|
|
|
| def work(b): |
| fs = sorted(glob.glob(f"{OUT}/buckets/b{b:02d}/*.npz")) |
| if not fs: return b, 0, 0, 0, 0, 0 |
| parts = [np.load(f) for f in fs] |
| ms = np.concatenate([p["ms"] for p in parts]); nat = np.concatenate([p["nat"] for p in parts]); comp = np.concatenate([p["comp"] for p in parts]) |
| cells = np.concatenate([p["cell"] for p in parts]) |
| def cat(k): return np.concatenate([p[k] for p in parts]) |
| Z, FX, R, S, P = cat("z"), cat("fx"), cat("R"), cat("S"), cat("P") |
| off = np.concatenate([[0], np.cumsum(nat)]) |
| groups = defaultdict(list) |
| for i in np.argsort(ms, kind="stable"): groups[comp[i]].append(i) |
| rep = np.empty(len(ms), np.int64); n_cmp = n_cell = 0; n_sing = int(sum(abs(np.linalg.det(c)) <= 1e-6 for c in cells)) |
| for g in groups.values(): |
| reps = [] |
| z = Z[off[g[0]]:off[g[0] + 1]]; species = [np.where(z == v)[0] for v in np.unique(z)] |
| for i in g: |
| ci = cells[i]; cpi = cellpar(ci); sl_i = slice(off[i], off[i + 1]); hit = -1 |
| for j, cpj in reps: |
| if np.any(np.abs(cpi[:3] - cpj[:3]) > 0.02 * cpj[:3]) or np.any(np.abs(cpi[3:] - cpj[3:]) > 1.0): continue |
| cj = cells[j] |
| |
| if np.abs(ci - cj).max() > 0.02 * cpj[:3].max(): continue |
| n_cell += 1; sl_j = slice(off[j], off[j + 1]) |
| if maxd(S[sl_i], ci, S[sl_j], cj, z, species, THR) >= THR: continue |
| n_cmp += 1 |
| same = max(maxd(R[sl_i], ci, R[sl_j], cj, z, species, THR), maxd(P[sl_i], ci, P[sl_j], cj, z, species, THR)) |
| if same < THR: hit = j; break |
| swap = max(maxd(R[sl_i], ci, P[sl_j], cj, z, species, THR), maxd(P[sl_i], ci, R[sl_j], cj, z, species, THR)) |
| if swap < THR: hit = j; break |
| if hit < 0: reps.append((i, cpi)); rep[i] = ms[i] |
| else: rep[i] = ms[hit] |
| os.makedirs(f"{OUT}/clusters", exist_ok=True) |
| np.savez(f"{OUT}/clusters/b{b:02d}.npz", ms=ms, rep=rep) |
| return b, len(ms), int((rep != ms).sum()), n_cell, n_cmp, n_sing |
|
|
|
|
| if __name__ == "__main__": |
| nw = int(sys.argv[1]) if len(sys.argv) > 1 else 64; t0 = time.time(); tot = dup = 0 |
| with Pool(nw) as pool: |
| nsing = 0 |
| for b, n, d, nc, nm, ns in pool.imap_unordered(work, range(NB)): |
| tot += n; dup += d; nsing += ns |
| print(f" bucket {b:02d}: {n} triplets, {d} duplicates, {nc} cell-compatible comparisons, {nm} saddle matches ({time.time()-t0:.0f}s)", flush=True) |
| print(f"pass 2 done: {tot} triplets, {dup} duplicates ({100*dup/max(tot,1):.2f}%), {nsing} singular cells, {time.time()-t0:.0f}s") |
|
|
