Bobchen1980's picture
Upload folder using huggingface_hub (part 2)
c902ee7 verified
Raw History Blame Contribute Delete
15.2 kB
#!/usr/bin/env python3
"""Frequency and coupling contributions to acoustic reduction error."""
import os
for key in ('OPENBLAS_NUM_THREADS','OMP_NUM_THREADS','MKL_NUM_THREADS','NUMEXPR_NUM_THREADS'):
os.environ[key]='2'
import argparse
import csv
import hashlib
import json
import sys
import zipfile
from pathlib import Path
import numpy as np
from scipy import linalg
from scipy.optimize import linear_sum_assignment
from scipy.sparse.linalg import eigsh
HERE=Path(__file__).resolve().parent
sys.path.insert(0,str(HERE.parent))
from acoustic_core import build_sparse,ports,CONFIG as CORE
CFG=json.loads((HERE/'config.json').read_text())
OUT=HERE/'results'
def dump(path, data):
path.write_text(json.dumps(data,indent=2,allow_nan=False)+'\n')
def savecsv(path,rows):
with path.open('w',newline='') as f:
w=csv.DictWriter(f,fieldnames=list(rows[0]));w.writeheader();w.writerows(rows)
def spectral_problem(n,name,complete=False):
cache=OUT/f'{name}_n{n}_spectrum.npz'
X,Y,rho,bulk,mass,C,J=build_sparse(n,name)
A=(C@C.T).tocsr()
B=ports(X,Y,bulk,CORE['source_centres'],True)
R=ports(X,Y,bulk,CORE['receiver_centres'],False)
if cache.exists() and zipfile.is_zipfile(cache):
z=np.load(cache);lam=z['eigenvalues'];V=z['eigenvectors']
else:
if complete:
lam,V=linalg.eigh(A.toarray(),check_finite=False,driver='evd')
else:
lam,V=eigsh(A,k=CFG['fine_modes'],sigma=-1e-7,which='LM',
tol=CFG['eigen_tolerance'],
v0=np.random.default_rng(673).normal(size=n*n))
order=np.argsort(lam);lam=lam[order];V=V[:,order]
lam[lam<1e-9]=0
temporary=cache.with_name(cache.stem+'.tmp.npz')
np.savez_compressed(temporary,eigenvalues=lam,eigenvectors=V,mass=mass,
source_coupling=V.T@B,receiver_coupling=R.T@V)
temporary.replace(cache)
eig_res=np.linalg.norm(A@V-V*lam[None,:],axis=0)/np.maximum(lam,1)
return {'omega':np.sqrt(lam),'V':V,'b':V.T@B,'c':R.T@V,'mass':mass,
'A':A,'B':B,'R':R,'eigen_residual':float(np.max(eig_res))}
def residue(b,c):
return np.einsum('oj,js->jos',c,b)
def response(t,omega,res):
return np.einsum('tj,jos->tos',np.cos(t[:,None]*omega[None,:]),res,optimize=True)
def gap(omega):
left=np.r_[np.inf,np.diff(omega)]
right=np.r_[np.diff(omega),np.inf]
return np.minimum(left,right)/np.maximum(omega,1e-100)
def restriction(V,mass_f,mass_c,nf,nc):
ratio=nf//nc
physical=V/np.sqrt(mass_f[:,None])
blocks=physical.reshape(nc,ratio,nc,ratio,V.shape[1]).mean(axis=(1,3))
W=blocks.reshape(nc*nc,-1)*np.sqrt(mass_c[:,None])
norms=np.linalg.norm(W,axis=0)
return W/np.maximum(norms,1e-300),norms
def match(left,right,wleft,wright):
overlap=left.T@right
il,ir=linear_sum_assignment(-overlap**2)
mac=overlap[il,ir]**2
accepted=(mac>=CFG['mac_threshold'])&(gap(wleft)[il]>=CFG['relative_frequency_gap'])&(gap(wright)[ir]>=CFG['relative_frequency_gap'])
accepted&=(wleft[il]>1e-7)&(wright[ir]>1e-7)
return il,ir,mac,np.sign(overlap[il,ir]),accepted
def cluster_angles(left,right,wleft,wright,assignment):
# Compare near-degenerate clusters as subspaces; exclude scalar shifts.
groups=[];start=1
for j in range(2,len(wleft)+1):
split=j==len(wleft) or (wleft[j]-wleft[j-1])/max(wleft[j],1e-100)>=CFG['near_cluster_tolerance']
if split:
if j-start>1: groups.append(np.arange(start,j))
start=j
rows=[]
for ids in groups:
center=float(np.mean(wleft[ids]))
if any(int(j) not in assignment for j in ids):
continue
candidates=np.array([assignment[int(j)] for j in ids],dtype=int)
rightq,_=linalg.qr(right[:,candidates],mode='economic')
values=linalg.svdvals(left[:,ids].T@rightq)
rows.append({'start_mode':int(ids[0]),'end_mode':int(ids[-1]),'dimension':len(ids),
'comparison_dimension':len(candidates),'frequency_center':center,
'smallest_principal_cosine':float(values.min()),
'largest_principal_angle_degrees':float(np.degrees(np.arccos(np.clip(values.min(),0,1))))})
return rows
def norm(x): return float(np.linalg.norm(x))
def cosine(a,b): return float(np.sum(a*b)/max(norm(a)*norm(b),1e-300))
def process(name):
n=CFG['coarse_grid'];nf=CFG['fine_grid'];t=np.linspace(0,CFG['time_end'],CFG['samples'])
coarse=spectral_problem(n,name,True);fine=spectral_problem(nf,name)
yc=response(t,coarse['omega'],residue(coarse['b'],coarse['c']))
yf_modes=response(t,fine['omega'],residue(fine['b'],fine['c']))
yf=np.load(HERE.parent/'propagation'/'results'/f'{name}_n{nf}.npz')['receiver_pressure']
yref=np.load(HERE.parent/'propagation'/'results'/f'{name}_n256.npz')['receiver_pressure']
ycdirect=np.load(HERE.parent/'propagation'/'results'/f'{name}_n{n}.npz')['receiver_pressure']
W,_=restriction(fine['V'],fine['mass'],coarse['mass'],nf,n)
ic,iff,mac_cf,sign_cf,accept_cf=match(coarse['V'],W,coarse['omega'],fine['omega'])
coarse_to_fine={int(i):(int(j),float(mac),float(sgn)) for i,j,mac,sgn,ok in zip(ic,iff,mac_cf,sign_cf,accept_cf) if ok}
fine_coverage=norm(yf_modes-yf)/norm(yf)
if fine_coverage>CFG['fine_response_coverage_limit']:
print(f'Coverage criterion not met for {name}: fine modal omission {fine_coverage:.4g}; retain full remainder and do not infer complete frequency attribution.',flush=True)
coverage={'material':name,'coarse_eigen_residual':coarse['eigen_residual'],
'fine_eigen_residual':fine['eigen_residual'],
'coarse_complete_response_error':norm(yc-ycdirect)/norm(ycdirect),
'fine_truncated_response_error':fine_coverage,
'fine_response_coverage_pass':fine_coverage<=CFG['fine_response_coverage_limit'],
'fine_to_256_response_difference':norm(yf-yref)/norm(yref),
'accepted_coarse_fine_pairs':len(coarse_to_fine),
'near_cluster_diagnostics':cluster_angles(coarse['V'][:,:CFG['fine_modes']],W,coarse['omega'][:CFG['fine_modes']],fine['omega'],{int(i):int(j) for i,j in zip(ic,iff)})}
pairrows=[];summary=[];couplingrows=[];components=[]
np.savez_compressed(OUT/f'{name}_coarse_fine_matching.npz',coarse_indices=ic,fine_indices=iff,mac=mac_cf,sign=sign_cf,accepted=accept_cf)
for method,m in CFG['models']:
label=f'{method}_m{m}'
raw=np.load(HERE.parent/'accuracy_cost'/'results'/f'{name}_n{n}_{label}.npz')
Q=raw['orthonormal_basis'];Vr=Q@raw['reduced_eigenvectors'];wr=np.sqrt(raw['reduced_eigenvalues'])
br=Vr.T@coarse['B'];cr=coarse['R'].T@Vr;rr=residue(br,cr)
yr=response(t,wr,rr);direct=raw['receiver_pressure']
ir,jc,mac_rc,sign_rc,accept_rc=match(Vr,coarse['V'],wr,coarse['omega'])
np.savez_compressed(OUT/f'{name}_{label}_matching.npz',rom_indices=ir,coarse_indices=jc,mac=mac_rc,sign=sign_rc,accepted=accept_rc)
sr=ir[accept_rc];sc=jc[accept_rc];ss=sign_rc[accept_rc]
rrc=rr[sr];rc=residue(coarse['b'][sc],coarse['c'][:,sc])
eqfreq=response(t,wr[sr],rrc)-response(t,coarse['omega'][sc],rrc)
eqres=response(t,coarse['omega'][sc],rrc-rc)
eqtail=yr-yc-eqfreq-eqres
# Align mode signs before the exact symmetric source/receiver residue split.
brsame=br[sr]*ss[:,None];crsame=cr[:,sr]*ss[None,:]
bcsame=coarse['b'][sc];ccsame=coarse['c'][:,sc]
eq_source=response(t,coarse['omega'][sc],residue(brsame-bcsame,(crsame+ccsame)/2))
eq_receiver=response(t,coarse['omega'][sc],residue((brsame+bcsame)/2,crsame-ccsame))
chain=[(int(l),int(j),coarse_to_fine[int(j)][0],float(mrc),coarse_to_fine[int(j)][1],float(src),coarse_to_fine[int(j)][2])
for l,j,mrc,src,ok in zip(ir,jc,mac_rc,sign_rc,accept_rc) if ok and int(j) in coarse_to_fine]
ri=np.array([a[0] for a in chain],dtype=int);ci=np.array([a[1] for a in chain],dtype=int);fi=np.array([a[2] for a in chain],dtype=int)
# Gauge: ROM and fine modes are both oriented toward the coarse mode.
srom=np.array([a[5] for a in chain]);sfine=np.array([a[6] for a in chain])
brr=br[ri]*srom[:,None];crr=cr[:,ri]*srom[None,:]
bff=fine['b'][fi]*sfine[:,None];cff=fine['c'][:,fi]*sfine[None,:]
rrom=residue(brr,crr);rfine=residue(bff,cff)
ritz=response(t,wr[ri],rrom)-response(t,coarse['omega'][ci],rrom)
grid=response(t,coarse['omega'][ci],rrom)-response(t,fine['omega'][fi],rrom)
couplings=response(t,fine['omega'][fi],rrom-rfine)
source=response(t,fine['omega'][fi],residue(brr-bff,(crr+cff)/2))
receiver=response(t,fine['omega'][fi],residue((brr+bff)/2,crr-cff))
tail=yr-yf-ritz-grid-couplings
# Frequency replacements retain modal residues and unmatched responses.
cf_no_ritz=yr-ritz
cf_fine_frequency=yr-ritz-grid
denom=norm(yf)
wgt=np.linalg.norm(rfine,axis=(1,2));wgtsum=max(float(wgt.sum()),1e-300)
signed_grid=(coarse['omega'][ci]-fine['omega'][fi])/fine['omega'][fi]
signed_ritz=(wr[ri]-coarse['omega'][ci])/fine['omega'][fi]
for k,(l,j,f,mrc,mcf,sr0,sf0) in enumerate(chain):
pairrows.append({'material':name,'method':method,'m':m,'rank':len(wr),
'rom_mode':l,'coarse_mode':j,'fine_mode':f,'mac_rom_coarse':mrc,'mac_coarse_fine':mcf,
'omega_rom':float(wr[l]),'omega_coarse':float(coarse['omega'][j]),'omega_fine':float(fine['omega'][f]),
'relative_grid_shift':float(signed_grid[k]),'relative_ritz_shift':float(signed_ritz[k]),
'fine_residue_norm':float(wgt[k]),'coarse_fine_shape_angle_degrees':float(np.degrees(np.arccos(np.sqrt(np.clip(mcf,0,1))))),
'rom_coarse_shape_angle_degrees':float(np.degrees(np.arccos(np.sqrt(np.clip(mrc,0,1))))),
'source_coupling_change_norm':norm(brr[k]-bff[k]),'receiver_coupling_change_norm':norm(crr[:,k]-cff[:,k]),
'fine_source_coupling_norm':norm(bff[k]),'fine_receiver_coupling_norm':norm(cff[:,k])})
error=yr-yf
comp=[ritz,grid,source,receiver,tail]
compnames=['ritz_frequency','grid_frequency','source_coupling','receiver_coupling','unmatched_modes']
for a,ca in enumerate(comp):
for b,cb in enumerate(comp):
components.append({'material':name,'method':method,'m':m,'component_a':compnames[a],
'component_b':compnames[b],'normalized_inner_product':float(np.sum(ca*cb)/denom**2)})
row={'material':name,'method':method,'m':m,'rank':len(wr),'accepted_same_grid_pairs':len(sr),
'accepted_three_grid_chain':len(chain),'same_grid_error':norm(yr-yc)/norm(yc),
'same_grid_frequency_component':norm(eqfreq)/norm(yc),
'same_grid_residue_component':norm(eqres)/norm(yc),
'same_grid_source_component':norm(eq_source)/norm(yc),
'same_grid_receiver_component':norm(eq_receiver)/norm(yc),
'same_grid_unmatched_component':norm(eqtail)/norm(yc),
'total_error_vs_128':norm(error)/denom,'total_error_vs_256':norm(yr-yref)/norm(yref),
'ritz_frequency_component':norm(ritz)/denom,'grid_frequency_component':norm(grid)/denom,
'source_coupling_component':norm(source)/denom,'receiver_coupling_component':norm(receiver)/denom,
'residue_component':norm(couplings)/denom,'unmatched_component':norm(tail)/denom,
'ritz_grid_cosine':cosine(ritz,grid),'ritz_grid_inner_product':float(np.sum(ritz*grid)/denom**2),
'error_without_ritz_shift_vs_128':norm(cf_no_ritz-yf)/denom,
'error_with_fine_frequencies_vs_128':norm(cf_fine_frequency-yf)/denom,
'error_without_ritz_shift_vs_256':norm(cf_no_ritz-yref)/norm(yref),
'error_with_fine_frequencies_vs_256':norm(cf_fine_frequency-yref)/norm(yref),
'matched_fine_response_omission':norm(yf-response(t,fine['omega'][fi],rfine))/denom,
'weighted_grid_shift':float(np.sum(wgt*signed_grid)/wgtsum),
'weighted_ritz_shift':float(np.sum(wgt*signed_ritz)/wgtsum),
'weighted_net_shift':float(np.sum(wgt*(signed_grid+signed_ritz))/wgtsum),
'weighted_mac_rom_coarse':float(np.sum(wgt*np.array([a[3] for a in chain]))/wgtsum),
'weighted_mac_coarse_fine':float(np.sum(wgt*np.array([a[4] for a in chain]))/wgtsum),
'opposite_frequency_shift_weight_fraction':float(np.sum(wgt[(signed_grid<0)&(signed_ritz>0)])/wgtsum),
'decomposition_relative_defect':norm(error-sum(comp))/max(norm(error),1e-300),
'coupling_split_relative_defect':norm(couplings-source-receiver)/max(norm(couplings),1e-300),
'stored_rom_response_error':norm(yr-direct)/norm(direct),
'minmax_min_difference':float(np.min(wr-coarse['omega'][:len(wr)])),
'same_grid_coupling_split_defect':norm(eqres-eq_source-eq_receiver)/max(norm(eqres),1e-300)}
summary.append(row)
np.savez_compressed(OUT/f'{name}_{label}_decomposition.npz',time=t,rom_response=yr,
coarse_response=yc,fine_response=yf,reference_256_response=yref,
ritz_frequency=ritz,grid_frequency=grid,source_coupling=source,
receiver_coupling=receiver,unmatched_modes=tail,
same_grid_frequency=eqfreq,same_grid_source=eq_source,
same_grid_receiver=eq_receiver,same_grid_unmatched=eqtail,
no_ritz_frequency_response=cf_no_ritz,fine_frequency_response=cf_fine_frequency)
savecsv(OUT/f'{name}_modal_pairs.csv',pairrows)
savecsv(OUT/f'{name}_summary.csv',summary)
savecsv(OUT/f'{name}_component_gram.csv',components)
dump(OUT/f'{name}_validation.json',coverage)
return summary,coverage
def main():
p=argparse.ArgumentParser();p.add_argument('--materials',nargs='+',default=CFG['materials']);args=p.parse_args()
if hasattr(os,'sched_getaffinity'):
available=set(os.sched_getaffinity(0));cpus=available&set(CFG['cpu_affinity'])
os.sched_setaffinity(0,cpus or set(sorted(available)[:CFG['threads']]))
OUT.mkdir(exist_ok=True)
allrows=[];validation=[]
for name in args.materials:
print('Computing',name,flush=True)
rows,checks=process(name);allrows.extend(rows);validation.append(checks)
print(json.dumps({'material':name,'fine_modal_error':checks['fine_truncated_response_error'],
'accepted_fine_pairs':checks['accepted_coarse_fine_pairs'],
'model_summary':[{k:r[k] for k in ['method','m','accepted_three_grid_chain','ritz_grid_cosine','total_error_vs_128','error_without_ritz_shift_vs_128']} for r in rows]}),flush=True)
savecsv(OUT/'summary.csv',allrows)
dump(OUT/'validation.json',{'config_sha256':hashlib.sha256((HERE/'config.json').read_bytes()).hexdigest(),
'code_sha256':hashlib.sha256(Path(__file__).read_bytes()).hexdigest(),'cases':validation})
if __name__=='__main__':main()