"""Four authorized estimates: two axial resolutions x two volume quadratures.""" import argparse import hashlib import itertools import json from pathlib import Path import resource import time import numpy as np from scipy.spatial import cKDTree if __package__: from .projector_remesh_probe import voxel_mesh, exact_distance, grouped from .route_feasibility import graph_from_edges, node_tensor from .physical_support_probe import statistics from .analyze_support_capacity_conditions import funnel, center_oracle else: from projector_remesh_probe import voxel_mesh, exact_distance, grouped from route_feasibility import graph_from_edges, node_tensor from physical_support_probe import statistics from analyze_support_capacity_conditions import funnel, center_oracle def tetra_rule(): small = (5-np.sqrt(5))/20 bary = np.full((4, 4), small) np.fill_diagonal(bary, (5+3*np.sqrt(5))/20) return bary def volume_samples(x, tet, raw, rule): p = x[tet] volume = abs(np.linalg.det(p[:, 1:]-p[:, :1]))/6 if rule == 'lumped_vertex': mass = np.bincount(tet.ravel(), weights=np.repeat(volume/4, 4), minlength=len(x)) return x, mass, raw if rule != 'tetra_four_point': raise ValueError(rule) bary = tetra_rule() points = np.einsum('qj,tjk->tqk', bary, p).reshape(-1, 3) values = np.einsum('qj,tjkl->tqkl', bary, raw[tet]).reshape(-1, 3, 3) return points, np.repeat(volume/4, 4), values def initial_field(x, tet): p = x[tet] volume = abs(np.linalg.det(p[:, 1:]-p[:, :1]))/6 mass = np.bincount(tet.ravel(), weights=np.repeat(volume/4, 4), minlength=len(x)) edgeids = np.array(list(itertools.combinations(range(4), 2))) edges = np.unique(np.sort(tet[:, edgeids].reshape(-1, 2), axis=1), axis=0) tensor, _, meta = node_tensor(x, tet, mass, exact_distance(x, 'square_rod'), graph_from_edges(len(x), edges), steps=0) return tensor, float(volume.sum()), meta def kernel_reference(anchors, radius, order): nodes, weights = np.polynomial.legendre.leggauss(order) xy = .1*(nodes+1) xx, yy = np.meshgrid(xy, xy, indexing='ij') ww = .01*np.outer(weights, weights) cache, results = {}, [] for x, y, z in anchors: end_distance = min(z, 8-z, radius) key = (float(x), float(y), float(end_distance)) if key not in cache: rho2 = (xx-x)**2+(yy-y)**2 A = 1-rho2/radius**2 cap = np.sqrt(np.maximum(radius**2-rho2, 0)) low, high = np.maximum(-cap, -end_distance), cap def primitive(t): return A*A*t-2*A*t**3/(3*radius**2)+t**5/(5*radius**4) integrand = np.where(A>0, primitive(high)-primitive(low), 0) cache[key] = float(np.sum(ww*integrand)) results.append(cache[key]) return np.array(results) def integrate(anchors, sample_x, sample_mass, sample_tensor, hz, contract, reference, reference_ok): radius = contract['radius'] tree = cKDTree(sample_x) n = len(anchors) tensor = np.zeros((n, 3, 3)) denominator, effective, eigen_min = np.zeros(n), np.zeros(n), np.zeros(n) layer_count = np.zeros(n, int) axial_span = np.zeros(n) batch_size = contract['query_batch_size'] for begin in range(0, n, batch_size): neighbors = tree.query_ball_point(anchors[begin:begin+batch_size], radius) for offset, indices in enumerate(neighbors): i = begin+offset ids = np.asarray(indices, int) delta = sample_x[ids]-anchors[i] kernel = np.maximum(1-np.sum(delta*delta, axis=1)/radius**2, 0)**2 weight = sample_mass[ids]*kernel good = weight>0 ids, delta, weight = ids[good], delta[good], weight[good] total = float(weight.sum()) if not np.isfinite(total) or total<=0: raise ValueError('Nonfinite or empty positive-volume quadrature') denominator[i] = total wn = weight/total tensor[i] = np.einsum('i,ijk->jk', wn, sample_tensor[ids]) effective[i] = 1/np.sum(wn*wn) mean = wn@delta covariance = (delta*wn[:, None]).T@delta-np.outer(mean, mean) eigen_min[i] = np.linalg.eigvalsh(covariance)[0]/radius**2 bins = np.floor(sample_x[ids, 2]/hz+.5+1e-12).astype(int) layer_mass = np.bincount(bins, weights=wn) layer_count[i] = int(np.sum(layer_mass >= contract['support_resolved']['minimum_layer_mass_fraction'])) axial_span[i] = np.ptp(sample_x[ids, 2]) relative_mass_error = abs(denominator/reference-1) support = (layer_count >= contract['support_resolved']['minimum_effective_axial_layers']) & (eigen_min > contract['support_resolved']['minimum_relative_support_second_moment_eigenvalue']) quality = reference_ok & (relative_mass_error <= contract['quadrature_quality']['kernel_mass_relative_error_max']) & (effective >= contract['quadrature_quality']['effective_quadrature_samples_min']) return dict(tensor=tensor, kernel_mass=denominator, reference_kernel_mass=reference, relative_kernel_mass_error=relative_mass_error, effective_samples=effective, minimum_relative_support_eigenvalue=eigen_min, effective_axial_layers=layer_count, axial_span=axial_span, support_resolved=support, quadrature_quality=quality) def region_masks(anchors): end = np.minimum(anchors[:, 2], 8-anchors[:, 2]) <= .5+1e-12 wall = (np.minimum(anchors[:, :2], .2-anchors[:, :2]).min(1) <= .05+1e-12) & ~end return {'all': np.ones(len(anchors), bool), 'interior': ~(end|wall), 'wall': wall, 'end': end} def main(): parser = argparse.ArgumentParser() parser.add_argument('output', type=Path) out = parser.parse_args().output contract_path = out/'execution_contract.json' contract = json.loads(contract_path.read_text())['O2'] with (out/'O2.started.json').open('x') as stream: json.dump({'contract_sha256':hashlib.sha256(contract_path.read_bytes()).hexdigest()}, stream) started = time.monotonic() source = Path(contract['anchor_source']) assert hashlib.sha256(source.read_bytes()).hexdigest() == contract['anchor_source_sha256'] anchors = np.load(source)['query'] assert len(anchors) == contract['anchor_count'] regions = region_masks(anchors) assert np.all(sum(m.astype(int) for key,m in regions.items() if key!='all')==1) ref24 = kernel_reference(anchors, .5, 24) ref48 = kernel_reference(anchors, .5, 48) reference_error = abs(ref24/ref48-1) reference_ok = reference_error <= contract['quadrature_quality']['reference_relative_agreement_max'] np.savez_compressed(out/'kernel_mass_reference.npz', query=anchors, order24=ref24, order48=ref48, relative_agreement=reference_error) results, arrays = {}, {} center = np.flatnonzero(np.linalg.norm(anchors-[.1,.1,4.], axis=1)<1e-12) assert len(center)==1 for nz in contract['z_cells']: x, tet, _ = voxel_mesh([np.linspace(0,.2,13), np.linspace(0,.2,13), np.linspace(0,8,nz+1)], 'six_tets') distance, _ = cKDTree(x).query(anchors) assert np.max(distance)<1e-10 raw, volume, meta = initial_field(x, tet) assert np.isclose(volume,.32) for rule in contract['weights']: name = f'z{nz}_{rule}' tick = time.monotonic() sx, sm, st = volume_samples(x,tet,raw,rule) assert np.isclose(sm.sum(),volume) and np.all(sm>0) a = integrate(anchors,sx,sm,st,8/nz,contract,ref48,reference_ok) modes = grouped(a['tensor'],.1)['code'] a['mode'] = modes np.savez_compressed(out/(name+'.npz'), query=anchors, **a) arrays[name] = a regional = {} for region,mask in regions.items(): n = int(mask.sum()) regional[region] = dict(queries=n, support_resolved_count=int(np.sum(mask&a['support_resolved'])), quadrature_quality_count=int(np.sum(mask&a['quadrature_quality'])), support_and_quality_count=int(np.sum(mask&a['support_resolved']&a['quadrature_quality'])), mode_counts={str(c):int(np.sum(mask&(modes==c))) for c in [-1,0,1,2,3]}, kernel_mass_error=statistics(a['relative_kernel_mass_error'][mask]), minimum_effective_layers=int(a['effective_axial_layers'][mask].min()) if n else None, effective_samples=statistics(a['effective_samples'][mask])) oracle,_ = center_oracle(a['tensor'][center[0]]) oracle.update(support_resolved=bool(a['support_resolved'][center[0]]), quadrature_quality=bool(a['quadrature_quality'][center[0]])) result = dict(name=name,z_cells=nz,rule=rule,nodes=len(x),tets=len(tet),samples=len(sx), source_field_sha256=hashlib.sha256(raw.tobytes()).hexdigest(), mesh_sha256=hashlib.sha256(x.tobytes()+tet.tobytes()).hexdigest(), initial_field=meta,regions=regional,center=oracle,wall_seconds=time.monotonic()-tick) (out/(name+'.json')).write_text(json.dumps(result,indent=2,allow_nan=False)+'\n') results[name] = result print(name,regional['all'],flush=True) comparisons = {} pairs = [('weight_z24','z24_lumped_vertex','z24_tetra_four_point'),('weight_z48','z48_lumped_vertex','z48_tetra_four_point'), ('resolution_lumped','z24_lumped_vertex','z48_lumped_vertex'),('resolution_four_point','z24_tetra_four_point','z48_tetra_four_point')] for label, first, second in pairs: a,b = arrays[first],arrays[second] fa,fb = grouped(a['tensor'],.1),grouped(b['tensor'],.1) qa = a['support_resolved']&a['quadrature_quality'] qb = b['support_resolved']&b['quadrature_quality'] same = fa['code']==fb['code'] eligible = qa&qb&same&np.isin(fa['code'],[1,2]) pe = np.linalg.norm(fa['projector']-fb['projector'],axis=(2,3)).max(1) regions_out = {} for region,mask in regions.items(): entry = funnel(a['tensor'],b['tensor'],mask) entry.update(support_quality_A_count=int(np.sum(mask&qa)),support_quality_B_count=int(np.sum(mask&qb)), support_quality_both_count=int(np.sum(mask&qa&qb)), physical_gates_and_same_two_group_projector=statistics(pe[mask&eligible]), mode_flips_among_support_quality_both=int(np.sum(mask&qa&qb&~same)), all_anchor_tensor_difference=statistics(np.linalg.norm(a['tensor']-b['tensor'],axis=(1,2))[mask])) regions_out[region] = entry comparisons[label] = dict(first=first,second=second,regions=regions_out) result = dict(contract=contract,reference_mass_max_relative_disagreement=float(reference_error.max()),estimates=results, comparisons=comparisons,wall_seconds=time.monotonic()-started,peak_rss_kib=resource.getrusage(resource.RUSAGE_SELF).ru_maxrss, full_acceptance='NOT_ESTABLISHED; preregistered numerical engineering gates only',O2_S='NOT_RUN') (out/'O2_result.json').write_text(json.dumps(result,indent=2,allow_nan=False)+'\n') if __name__=='__main__': main()