216 lines
14 KiB
Python
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()
|