Files
MeltMind/tools/run_o2a_transverse_refinement.py

216 lines
14 KiB
Python

"""Frozen O2-A: six new estimates and two source-verified reused estimates.
No reference integration, optimization, training, or change of numerical gates.
"""
import argparse
import csv
import hashlib
import json
import os
from pathlib import Path
import resource
import time
import numpy as np
from scipy.spatial import cKDTree
if __package__:
from .run_volume_quadrature_trial import initial_field, volume_samples, integrate, region_masks
from .projector_remesh_probe import voxel_mesh, grouped
from .analyze_support_capacity_conditions import center_oracle
else:
from run_volume_quadrature_trial import initial_field, volume_samples, integrate, region_masks
from projector_remesh_probe import voxel_mesh, grouped
from analyze_support_capacity_conditions import center_oracle
MIRROR = np.diag([-1., 1., 1.])
RULES = ('lumped_vertex', 'tetra_four_point')
def sha(path):
return hashlib.sha256(Path(path).read_bytes()).hexdigest()
def write_json(path, value):
Path(path).write_text(json.dumps(value, indent=2, allow_nan=False)+'\n')
def stats(values):
v = np.asarray(values)
return dict(count=int(v.size), minimum=float(v.min()) if v.size else None,
median=float(np.median(v)) if v.size else None,
p95=float(np.quantile(v, .95)) if v.size else None,
maximum=float(v.max()) if v.size else None)
def mirror_points(points):
return points @ MIRROR + np.array([.2, 0., 0.])
def mirror_map(anchors):
distances, ids = cKDTree(anchors).query(mirror_points(anchors))
if distances.max() > 1e-10 or len(np.unique(ids)) != len(ids):
raise ValueError('Mirror does not bijectively map fixed anchors')
return ids
def mesh(nx, mirrored):
x, tet, _ = voxel_mesh([np.linspace(0, .2, nx+1), np.linspace(0, .2, nx+1), np.linspace(0, 8, 49)], 'six_tets')
return (mirror_points(x) if mirrored else x), tet
def diagnostics(tensor):
val, vec = np.linalg.eigh(tensor)
scale = np.maximum(val[:, 2], 1e-12)
gaps = np.stack(((val[:, 2]-val[:, 1])/scale, (val[:, 1]-val[:, 0])/scale), axis=1)
axis = vec[:, :, 0]
axis_p = axis[:, :, None]*axis[:, None, :]
planar = np.linalg.eigvalsh(tensor[:, :2, :2])
signed = np.stack((tensor[:, 0, 0]-tensor[:, 1, 1], 2*tensor[:, 0, 1]), axis=1)
return dict(eigenvalues_descending=val[:, ::-1], normalized_gaps=gaps,
split=val[:, 2]-val[:, 1], xy_split=planar[:, 1]-planar[:, 0], signed=signed,
axis_projector=axis_p, axis_eligible=(val.sum(1)>1e-10)&(gaps[:, 1]>.1),
axis_error=np.linalg.norm(axis_p-np.diag([0., 0., 1.]), axis=(1, 2)))
def pair_summary(a, b, masks):
da, db = diagnostics(a['tensor']), diagnostics(b['tensor'])
fa, fb = grouped(a['tensor'], .1), grouped(b['tensor'], .1)
qa, qb = a['support_resolved'] & a['quadrature_quality'], b['support_resolved'] & b['quadrature_quality']
both = qa & qb
same = fa['code'] == fb['code']
grouped_ok = both & same & np.isin(fa['code'], [1, 2])
axis_ok = both & da['axis_eligible'] & db['axis_eligible']
pe = np.linalg.norm(fa['projector']-fb['projector'], axis=(2, 3)).max(1)
ae = np.linalg.norm(da['axis_projector']-db['axis_projector'], axis=(1, 2))
result = {}
for name, m in masks.items():
result[name] = dict(N=int(m.sum()), support_quality_A=int((m & qa).sum()),
support_quality_B=int((m & qb).sum()), support_quality_both=int((m & both).sum()),
all_mode_flips=int((m & ~same).sum()), qualified_mode_flips=int((m & both & ~same).sum()),
grouped_projector_difference=stats(pe[m & grouped_ok]),
axis_and_complement_plane_projector_difference=stats(ae[m & axis_ok]),
all_tensor_difference=stats(np.linalg.norm(a['tensor']-b['tensor'], axis=(1, 2))[m]))
return result
def analyze(out, contract):
anchors = np.load(out/'fixed_anchors.npz')['query']
masks = region_masks(anchors)
center = np.flatnonzero(np.linalg.norm(anchors-[.1,.1,4.], axis=1)<1e-12)
assert len(center)==1
c = int(center[0]); masks['center'] = np.arange(len(anchors))==c
estimates, arrays, regional_rows, endpoint_rows, center_rows = {}, {}, [], [], []
for spec in contract['estimates']:
name = spec['name']
a = dict(np.load(out/(name+'.npz'))); arrays[name] = a
assert np.array_equal(a['query'], anchors)
d = diagnostics(a['tensor']); f = grouped(a['tensor'], .1)
assert np.array_equal(a['mode'], f['code'])
qa = a['support_resolved'] & a['quadrature_quality']
regions = {}
for region, mask in masks.items():
entry = dict(N=int(mask.sum()), support=int((mask&a['support_resolved']).sum()),
quality=int((mask&a['quadrature_quality']).sum()), both=int((mask&qa).sum()),
axis_eligible_and_both=int((mask&qa&d['axis_eligible']).sum()),
mode_counts={str(k):int((mask&(f['code']==k)).sum()) for k in [-1,0,1,2,3]},
full_spectral_split=stats(d['split'][mask]), xy_block_split=stats(d['xy_split'][mask]),
axis_projector_error=stats(d['axis_error'][mask&qa&d['axis_eligible']]),
kernel_mass_relative_error=stats(a['relative_kernel_mass_error'][mask]),
effective_layers=stats(a['effective_axial_layers'][mask]))
regions[region] = entry
regional_rows.append(dict(estimate=name, region=region, N=entry['N'], support=entry['support'], quality=entry['quality'], both=entry['both'], split_median=entry['full_spectral_split']['median'], split_p95=entry['full_spectral_split']['p95'], xy_split_median=entry['xy_block_split']['median'], xy_split_p95=entry['xy_block_split']['p95'], axis_valid_N=entry['axis_eligible_and_both'], axis_P95=entry['axis_projector_error']['p95']))
oracle, _ = center_oracle(a['tensor'][c])
t = a['tensor'][c]
decomposition = dict(planar_mean_bias_squared=float(2*(np.trace(t[:2,:2])/2-.5)**2),
planar_split_squared_over_two=float(d['xy_split'][c]**2/2),
axial_squared=float(t[2,2]**2), cross_squared=float(2*np.sum(t[:2,2]**2)))
assert np.isclose(sum(decomposition.values()), oracle['tensor_frobenius_error_to_analytic']**2, atol=1e-14)
oracle.update(full_spectral_split=float(d['split'][c]), xy_block_split=float(d['xy_split'][c]), signed_anisotropy=d['signed'][c].tolist(), tensor=t.tolist(), frobenius_squared_decomposition=decomposition)
center_rows.append(dict(estimate=name, split=oracle['full_spectral_split'], xy_split=oracle['xy_block_split'], frobenius=oracle['tensor_frobenius_error_to_analytic'], axis_error=oracle['axis_projector_error_to_analytic'], Txx_minus_Tyy=float(d['signed'][c,0]), two_Txy=float(d['signed'][c,1])))
ends = masks['end']
endpoint = dict(eigenvalues_descending=[stats(d['eigenvalues_descending'][ends,i]) for i in range(3)], normalized_gaps=[stats(d['normalized_gaps'][ends,i]) for i in range(2)], support_quality=regions['end'])
for i in np.flatnonzero(ends):
endpoint_rows.append(dict(estimate=name, anchor=int(i), x=float(anchors[i,0]), y=float(anchors[i,1]), z=float(anchors[i,2]), lambda1=float(d['eigenvalues_descending'][i,0]), lambda2=float(d['eigenvalues_descending'][i,1]), lambda3=float(d['eigenvalues_descending'][i,2]), gap12=float(d['normalized_gaps'][i,0]), gap23=float(d['normalized_gaps'][i,1]), support=bool(a['support_resolved'][i]), quality=bool(a['quadrature_quality'][i]), mode=int(f['code'][i])))
np.savez_compressed(out/(name+'_diagnostics.npz'), query=anchors, **d)
estimates[name] = dict(spec=spec, center=oracle, regions=regions, endpoint=endpoint)
comparisons, mirror_checks, rates = {}, {}, {}
ids = mirror_map(anchors)
for rule in RULES:
for lo, hi in [(12,24),(24,48)]:
first, second = f'xy{lo}_standard_{rule}', f'xy{hi}_standard_{rule}'
comparisons[f'{lo}_to_{hi}_{rule}'] = pair_summary(arrays[first], arrays[second], masks)
a, b = arrays[f'xy24_standard_{rule}'], arrays[f'xy24_mirror_{rule}']
predicted = MIRROR @ a['tensor'][ids] @ MIRROR
cov_error = np.linalg.norm(b['tensor']-predicted, axis=(1,2))
da, db = diagnostics(a['tensor']), diagnostics(b['tensor'])
mirror_checks[rule] = dict(covariance_error=stats(cov_error), center_signed_standard=da['signed'][c].tolist(), center_signed_mirror=db['signed'][c].tolist(),
signed_reflection_rule='(Txx-Tyy,2Txy) maps to (Txx-Tyy,-2Txy) at reflected physical anchors; no arbitrary eigvector signs',
signed_covariance_max=float(abs(db['signed']-da['signed'][ids]*[1,-1]).max()),
same_physical_anchor_comparison=pair_summary(a,b,masks))
rows = [estimates[f'xy{n}_standard_{rule}'] for n in [12,24,48]]
rate = {}
for metric, values in [('center_split',[r['center']['full_spectral_split'] for r in rows]), ('center_Frobenius',[r['center']['tensor_frobenius_error_to_analytic'] for r in rows]), ('interior_split_median',[r['regions']['interior']['full_spectral_split']['median'] for r in rows]), ('interior_split_p95',[r['regions']['interior']['full_spectral_split']['p95'] for r in rows])]:
rate[metric] = dict(values=values, observed_log2_ratios=[float(np.log2(values[i]/values[i+1])) if values[i]>0 and values[i+1]>0 else None for i in range(2)], interpretation='Observed reduction in this statistic; not proven continuum error order, particularly off-center.')
rates[rule] = rate
for name, rows in [('regions.csv',regional_rows),('centers.csv',center_rows),('endpoints.csv',endpoint_rows)]:
with (out/name).open('w') as stream:
writer=csv.DictWriter(stream,fieldnames=list(rows[0])); writer.writeheader(); writer.writerows(rows)
result=dict(estimates=estimates, refinement_comparisons=comparisons, mirror=mirror_checks, observed_rates=rates,
caveats=['Interior off-center plane splitting may reflect box/kernel geometry; no new continuum reference exists in O2-A.', 'A gap near 0.1 is not an exact repeated root.', 'Unresolved or bad-quality anchors are excluded only from conditional projector comparisons, retained in all-anchor counts and splits.', 'Old nz24 endpoint support failures remain outside this experiment; their bilateral qualified denominator remains zero.'])
write_json(out/'O2A_result.json',result)
return result
def main():
p=argparse.ArgumentParser(); p.add_argument('output',type=Path); p.add_argument('--analyze-only',action='store_true'); args=p.parse_args()
out=args.output; contract=json.loads((out/'execution_contract.json').read_text())
if args.analyze_only:
analyze(out,contract); return
for path,digest in contract['input_sha256'].items():
assert sha(path)==digest, path
started=time.monotonic()
with (out/'O2A.started.json').open('x') as stream:
json.dump(dict(pid=os.getpid(),contract_sha256=sha(out/'execution_contract.json'),started_unix=time.time()),stream)
old=Path(contract['reuse_directory']); base=contract['numerics']
anchors=np.load(base['anchor_source'])['query']
assert len(anchors)==2197
ref=dict(np.load(old/'kernel_mass_reference.npz')); assert np.array_equal(anchors,ref['query'])
reference_ok=ref['relative_agreement']<=base['quadrature_quality']['reference_relative_agreement_max']
np.savez_compressed(out/'fixed_anchors.npz', query=anchors, mirror_index=mirror_map(anchors), **{k:v for k,v in region_masks(anchors).items()})
records=[]
for spec in contract['estimates']:
if not spec['reuse']: continue
source=old/f"z48_{spec['rule']}.npz"
# Byte-for-byte reuse includes arrays and original modes/gates, never regenerate.
(out/(spec['name']+'.npz')).write_bytes(source.read_bytes())
records.append(dict(**spec,source=str(source),sha256=sha(source),wall_seconds_this_run=0.,timing_scope='Reused; original timing in source companion JSON'))
for nx, mirrored in [(24,False),(48,False),(24,True)]:
tick=time.monotonic(); print('MESH',nx,'mirror',mirrored,flush=True)
x,tet=mesh(nx,mirrored)
assert cKDTree(x).query(anchors)[0].max()<1e-10
raw,volume,meta=initial_field(x,tet)
assert np.isclose(volume,.32,rtol=1e-12)
mesh_seconds=time.monotonic()-tick
mesh_digest=hashlib.sha256(x.tobytes()+tet.tobytes()).hexdigest()
raw_digest=hashlib.sha256(raw.tobytes()).hexdigest()
for rule in RULES:
name=f'xy{nx}_{"mirror" if mirrored else "standard"}_{rule}'
tick=time.monotonic(); print('INTEGRATE',name,flush=True)
sx,sm,st=volume_samples(x,tet,raw,rule)
assert np.all(np.isfinite(sm)) and np.all(sm>0) and np.isclose(sm.sum(),volume)
a=integrate(anchors,sx,sm,st,8/48,base,ref['order48'],reference_ok)
assert np.all(np.isfinite(a['tensor']))
a['mode']=grouped(a['tensor'],.1)['code']
np.savez_compressed(out/(name+'.npz'),query=anchors,**a)
record=dict(name=name,reuse=False,nx=nx,nz=48,mirrored=mirrored,rule=rule,nodes=len(x),tets=len(tet),samples=len(sx),volume=volume,mesh_sha256=mesh_digest,raw_field_sha256=raw_digest,initial_field=meta,shared_mesh_and_field_seconds=mesh_seconds,quadrature_seconds=time.monotonic()-tick,peak_rss_kib_so_far=resource.getrusage(resource.RUSAGE_SELF).ru_maxrss)
write_json(out/(name+'.json'),record); records.append(record)
print('DONE',name,'seconds',record['quadrature_seconds'],flush=True)
del sx,sm,st,a
del x,tet,raw
analyze(out,contract)
write_json(out/'work_receipt.json',dict(status='COMPLETED',pid=os.getpid(),wall_seconds=time.monotonic()-started,peak_rss_kib=resource.getrusage(resource.RUSAGE_SELF).ru_maxrss,records=records,new_estimates=6,reused_estimates=2,training=False,new_reference_integration=False))
print('COMPLETE',time.monotonic()-started,flush=True)
if __name__=='__main__':
main()