Files
MeltMind/tools/draw_s1_sampled.py
T

184 lines
13 KiB
Python

"""One immutable M2 v1.2 PPS draw per panel part; saved-count cost only."""
import argparse
import csv
import fcntl
import hashlib
import json
import os
from pathlib import Path
import platform
import resource
import shutil
import time
from datetime import datetime, timezone
import numpy as np
PRECHECK_COMMIT = '81f56afaca38304a4b5f48921927f97669ebbac9'
PANEL_SHA = 'c594110b017ad8c62a542e4f634ce2879ccd1c30bd818429e73c0910a57a1e69'
COUNT_SHA = '21d11a0d975735ffb4cba355aea8abe0fdfe4f3ef7d7f586444c6ad8113be342'
def sha(p):
return hashlib.sha256(Path(p).read_bytes()).hexdigest()
def now():
return datetime.now(timezone.utc).isoformat()
def write(p, obj):
with Path(p).open('x') as f:
json.dump(obj, f, indent=2, ensure_ascii=False, allow_nan=False)
f.write('\n')
def main():
a = argparse.ArgumentParser()
a.add_argument('--input', type=Path, default=Path('artifacts/s1-panel-precheck-2026-11-14'))
a.add_argument('--output', type=Path, default=Path('artifacts/s1-sampled-draw-2026-11-14'))
args = a.parse_args()
source, out = args.input, args.output
assert np.__version__ == '1.26.4', 'Frozen numerical environment required'
assert sha(source/'panel.csv') == PANEL_SHA
assert sha(source/'count_contract.json') == COUNT_SHA
panel = list(csv.DictReader((source/'panel.csv').open()))
assert len(panel) == 24 and len({r['source_key'] for r in panel}) == 24
assert [int(r['panel_index']) for r in panel] == list(range(24))
out.mkdir(exist_ok=False)
with (out/'execution.lock').open('x') as lock:
fcntl.flock(lock, fcntl.LOCK_EX | fcntl.LOCK_NB)
started = time.monotonic()
write(out/'started.json', dict(started_utc=now(), pid=os.getpid(),
action='Generate 24 primary draws and sum existing counts; no O2/S1/training',
slack_start='https://arcticnimbus.slack.com/archives/C0C78UFKGRM/p1794637933386369',
duplicate_check='No existing output directory; exclusive creation and lock; no Python processes seen before start'))
docs = ['docs/s1-m2-v1.2-draw-current-source-2026-11-14.md',
'docs/s1-m2-v1.2-draw-go-2026-11-14.txt']
contract = dict(version='M2 v1.2 sampled', frozen_before_first_draw_utc=now(),
precheck_commit=PRECHECK_COMMIT, panel_sha256=PANEL_SHA, count_contract_sha256=COUNT_SHA,
code_sha256=sha(__file__), code_path='tools/draw_s1_sampled.py',
document_sha256={p: sha(p) for p in docs}, numpy=np.__version__, python=platform.python_version(),
candidates='All original-pose nodes with d>0, ascending original tetra-submesh ID; raw VTU IDs strictly ascending in same order',
distribution='iid with replacement, p=mass[candidates]/np.sum(mass[candidates], dtype=float64)',
algorithm='Generator(PCG64(SeedSequence([2026111400, numeric_prefix]))).choice(candidate_ids, size=2000, replace=True, p=probabilities)',
draw_count=2000, primary_seed=2026111400, permutation_seeds=list(range(2026111401,2026111406)),
bootstrap_seed=2026111406, permutations_executed=False, bootstrap_executed=False,
identity='panel_index, case, source_key, numeric_prefix preserved; one draw per part reused across all folds',
fold_roles=None, fold_status='Actual fold assignment not specified in current document; must freeze before scoring. Source isolation mandatory.',
exact_visits='Python integer sum of saved neighbor_counts[i] over ALL distinct drawn IDs, once per ID, before O2 eligibility',
common_eligible_draws=None, n_ref=None, eligibility_status='Unknown until O2; no prefilter except d>0',
supersedes='Only historical v1.1 reference/query/rank/shortfall clauses; original panel and count files unchanged',
full_source_field='All four-point source positions/masses and original nodal-gradient tensors, full-part R/t_part/R_g retained for future O2',
future_per_field_wall_seconds=1800, future_per_field_rss_bytes=1342177280,
timing_scenario_seconds_per_visit=0.73e-6, timing_scenario_is_bound=False,
visit_alarm=500000000, visit_hard_cap=None, O2_executed=False, S1_scoring=False, training=False)
write(out/'draw_contract.json', contract)
shutil.copy2(source/'panel.csv', out/'panel.csv')
shutil.copy2(source/'count_contract.json', out/'historical_count_contract.json')
rows = []
for p in panel:
t0 = time.monotonic()
case = p['case']; src = source/case; dst = out/case; dst.mkdir()
r = json.loads((src/'result.json').read_text())
assert r['status'] == 'COUNT_COMPLETE'
for name, h in r['output_sha256'].items():
assert sha(src/name) == h, (case, name)
with np.load(src/'counts.npz', allow_pickle=False) as z:
mass = z['node_lumped_mass']; counts = z['neighbor_counts']; boundary = z['boundary_mask']
distance = np.load(src/'boundary_distance_raw.npy', allow_pickle=False)
with np.load(src/'geometry.npz', allow_pickle=False) as z:
raw_ids = z['raw_node_ids']; edges = z['edges']
assert np.array_equal(mass, z['node_volume_raw'])
n = len(mass)
assert n == int(p['tet_nodes']) == r['nodes']
assert mass.dtype == np.float64 and counts.dtype == np.int64
assert all(v.shape == (n,) for v in [mass, counts, distance, raw_ids, boundary])
assert np.isfinite(mass).all() and (mass > 0).all()
assert np.isfinite(distance).all() and (distance >= 0).all()
assert (counts >= 0).all() and np.array_equal(boundary, distance == 0)
assert (np.diff(raw_ids) > 0).all()
ids = np.flatnonzero(distance > 0)
positive_mass = mass[ids].sum(dtype=np.float64)
probabilities = mass[ids]/positive_mass
prefix = int(p['numeric_prefix'])
rng = np.random.Generator(np.random.PCG64(np.random.SeedSequence([2026111400, prefix])))
draws = rng.choice(ids, size=2000, replace=True, p=probabilities)
unique, inverse, multiplicity = np.unique(draws, return_inverse=True, return_counts=True)
assert np.array_equal(unique[inverse], draws) and int(multiplicity.sum()) == 2000
visits = sum(int(counts[i]) for i in unique)
selected = np.zeros(n, bool); selected[unique] = True
endpoint_mask = selected[edges]
incident_edges = int(endpoint_mask.any(axis=1).sum())
directed_endpoints = int(endpoint_mask.sum())
max_neighbors = int(counts[unique].max())
# Full input vectors let a reviewer reproduce every draw and exact visit sum.
np.savez_compressed(dst/'inputs.npz', node_lumped_mass=mass, neighbor_counts=counts,
boundary_distance_raw=distance, raw_node_ids=raw_ids, candidate_ids=ids,
candidate_probabilities=probabilities)
np.savez_compressed(dst/'draw.npz', draw_ids=draws, draw_raw_ids=raw_ids[draws],
unique_ids=unique, unique_raw_ids=raw_ids[unique], multiplicity=multiplicity,
draw_to_unique=inverse, unique_mass=mass[unique], unique_probability=mass[unique]/positive_mass,
unique_neighbor_counts=counts[unique])
with (dst/'draw_slots.csv').open('x') as f:
w=csv.writer(f,lineterminator='\n');w.writerow(['draw_slot','node_id','raw_vtu_node_id'])
w.writerows(zip(range(2000), draws.tolist(), raw_ids[draws].tolist()))
with (dst/'unique.csv').open('x') as f:
w=csv.writer(f,lineterminator='\n');w.writerow(['node_id','raw_vtu_node_id','multiplicity','mass','probability','neighbor_count'])
w.writerows(zip(unique.tolist(),raw_ids[unique].tolist(),multiplicity.tolist(),mass[unique].tolist(),(mass[unique]/positive_mass).tolist(),counts[unique].tolist()))
# Explicit conservative planning allowances, not measured RSS or a proven bound.
s = int(r['four_point_sources']); u = len(unique)
ledger = dict(measured_full_count_process_peak=r['peak_rss_bytes'],
full_source_tensor_and_construction_allowance=144*s,
full_raw_tensor_support_and_copy_allowance=160*n,
full_query_kernel_scratch_allowance=512*max_neighbors,
sampled_kernel_and_O2_readout_allowance=1024*u,
saved_anchor_edge_endpoint_allowance=128*directed_endpoints,
edge_processing_block_allowance=512*4096,
allocator_IO_and_unmodelled_reserve=256*2**20)
planned_rss=sum(ledger.values())
memory = dict(case=case, components_bytes=ledger, planning_total_bytes=planned_rss,
budget_bytes=1342177280, below_budget_in_scenario=planned_rss <= 1342177280,
scope='Existing full-source count peak is baseline (positions/masses/tree/topology included). Add full source tensors and one construction copy, full raw field, single-query scratch, sampled node and edge outputs, block temporaries and reserve. Conservative allowances may overlap. Not measured O2 RSS or a guaranteed bound.',
implementation_constraints=['One field/process at a time; no parallel cases',
'Keep all source points and full raw field; no source thinning',
'Query one unique anchor at a time; never retain all radius-neighbor lists',
'O2 arrays indexed by unique anchors only; edge processing <=4096 directed endpoints/block',
'Use anchor B only for its incident edge directions; no neighbor-anchor integration',
'Write outputs before supervisor completion; scratch released between anchors'])
write(dst/'memory_plan.json',memory)
shutil.copy2(src/'result.json', dst/'precheck_result.json')
receipt=dict(case=case, source_key=p['source_key'], numeric_prefix=prefix, panel_index=int(p['panel_index']),
tertile=int(p['tertile']), status='DRAW_COMPLETE', seed_sequence=[2026111400,prefix],
nodes=n, tets=int(p['tet_cells']), full_four_point_sources=s,
positive_candidates=len(ids), draws=2000, unique_drawn=u, repeated_slots=2000-u,
positive_mass=float(positive_mass), total_mass=float(mass.sum()),
positive_mass_fraction=float(positive_mass/mass.sum()),
radius=r['radius'], t_part=r['t_part'], exact_unique_visits=visits,
repeated_slot_visits_diagnostic=sum(int(counts[i]) for i in draws),
min_unique_neighbors=int(counts[unique].min()), max_unique_neighbors=max_neighbors,
incident_undirected_edges=incident_edges, directed_anchor_edge_endpoints=directed_endpoints,
future_kernel_scenario_0_73us_seconds=visits*0.73e-6,
future_kernel_scenario_exceeds_1800s=visits*0.73e-6 > 1800,
future_memory_planning_bytes=planned_rss, future_memory_scenario_exceeds_budget=planned_rss>1342177280,
visit_alarm_5e8=visits>500000000, common_eligible_draws=None,n_ref=None,
fold_roles=None, fold_draw_reuse=True, input_files_sha256=r['output_sha256'],
precheck_result_sha256=sha(src/'result.json'),
output_sha256={q.name:sha(q) for q in sorted(dst.iterdir()) if q.is_file()},
wall_seconds=time.monotonic()-t0, completed_utc=now(), new_distance_queries=0,
new_neighbor_count_queries=0,new_kernel_evaluations=0,S1_scoring=False,training=False)
write(dst/'receipt.json',receipt)
rows.append({k:receipt[k] for k in ['panel_index','case','source_key','numeric_prefix','tertile','nodes','positive_candidates','draws','unique_drawn','repeated_slots','exact_unique_visits','max_unique_neighbors','incident_undirected_edges','directed_anchor_edge_endpoints','future_kernel_scenario_0_73us_seconds','future_kernel_scenario_exceeds_1800s','future_memory_planning_bytes','future_memory_scenario_exceeds_budget','visit_alarm_5e8','common_eligible_draws','n_ref']})
print(json.dumps(rows[-1]),flush=True)
with (out/'summary.csv').open('x') as f:
w=csv.DictWriter(f,fieldnames=list(rows[0]),lineterminator='\n');w.writeheader();w.writerows(rows)
write(out/'completion.json',dict(status='COMPLETE',parts=len(rows),total_draws=48000,
total_unique=sum(r['unique_drawn'] for r in rows),total_exact_unique_visits=sum(r['exact_unique_visits'] for r in rows),
wall_seconds=time.monotonic()-started,process_peak_rss_bytes=resource.getrusage(resource.RUSAGE_SELF).ru_maxrss*1024,
completed_utc=now(),new_distance_queries=0,new_neighbor_count_queries=0,new_kernel_evaluations=0,
S1_scoring=False,training=False,outputs_sha256={str(p.relative_to(out)):sha(p) for p in sorted(out.rglob('*')) if p.is_file() and p.name!='execution.lock'}))
if __name__ == '__main__':
main()