Download studies/patch_2d/run_patch.py from soundai2016/ADComp: direct link, hf CLI and curl.
- Browser
- Download file 13.6 kB
-
https://huggingface.co/soundai2016/ADComp/resolve/main/studies/patch_2d/run_patch.py
- Command line
-
hf download hf://soundai2016/ADComp/studies/patch_2d/run_patch.py
-
curl -L -o run_patch.py https://huggingface.co/soundai2016/ADComp/resolve/main/studies/patch_2d/run_patch.py
13.6 kB
| #!/usr/bin/env python3 | |
| """Local dynamic condensation for heterogeneous cavity acoustics. | |
| All spaces project the same physical mass and stiffness matrices. | |
| Craig--Bampton spaces retain the interface coordinates and fixed-interface modes. | |
| """ | |
| import os | |
| for k in ('OPENBLAS_NUM_THREADS','OMP_NUM_THREADS','MKL_NUM_THREADS'): | |
| os.environ[k]='2' | |
| import json, hashlib, time, csv | |
| from pathlib import Path | |
| import numpy as np | |
| from scipy import linalg, sparse | |
| HERE=Path(__file__).resolve().parent | |
| CFG={ | |
| 'experiment':'local_dynamic_condensation', | |
| 'status':'development diagnostic with analytic material fields', | |
| 'materials':['rotated_stripes','double_inclusion','smooth_checker'], | |
| 'grids':[16,24,32], 'reference_grid':48, 'audit_grid':64, | |
| 'audit_material':'rotated_stripes', 'internal_modes_per_patch':[0,4,8,16,32], | |
| 'interface':'one exact pressure row x_index=n/2-1; all n nodes retained once', | |
| 'source_centres':[[.19,.76],[.54,.47],[.81,.22]], | |
| 'receiver_centres':[[.22,.21],[.79,.77],[.28,.69],[.68,.33]], | |
| 'source_receiver_sigma':.07, 'time_end':8., 'samples':641, | |
| 'frequency_cycles_per_time':[.1,4.5,121], 'laplace_eta':.2, | |
| 'short_time_end':2., 'boundary':'rigid walls', | |
| 'material_information':'analytic rho and K resampled independently on every grid', | |
| 'clock':'exact semidiscrete modal propagation; initial impulse', | |
| 'coarse_baseline':'full FV on round(sqrt(retained pressure DOF)) cells per side', | |
| 'precision':'float64', 'threads':2, | |
| } | |
| def dump(path,obj): | |
| path.write_text(json.dumps(obj,indent=2,allow_nan=False)+'\n') | |
| def material(n,name): | |
| x=(np.arange(n)+.5)/n; X,Y=np.meshgrid(x,x,indexing='ij') | |
| if name=='rotated_stripes': | |
| rho=np.exp(.65*np.sin(4*np.pi*(.8*X+.6*Y))+.1*np.cos(2*np.pi*Y)) | |
| bulk=np.exp(-.45*np.sin(4*np.pi*(.8*X+.6*Y))+.12*np.sin(2*np.pi*X)) | |
| elif name=='double_inclusion': | |
| a=np.exp(-((X-.34)**2+(Y-.35)**2)/(2*.1**2)) | |
| b=np.exp(-((X-.70)**2+(Y-.67)**2)/(2*.12**2)) | |
| rho=np.exp(1.2*a-.55*b+.1*np.cos(2*np.pi*X)) | |
| bulk=np.exp(-.8*a+.9*b+.1*np.sin(2*np.pi*Y)) | |
| elif name=='smooth_checker': | |
| z=np.cos(4*np.pi*X)*np.cos(4*np.pi*Y) | |
| rho=np.exp(.8*z+.1*np.sin(2*np.pi*X)) | |
| bulk=np.exp(-.7*z+.15*np.cos(2*np.pi*Y)) | |
| else: raise KeyError(name) | |
| return X,Y,rho,bulk | |
| def build(n,name): | |
| X,Y,rho,bulk=material(n,name); h=1/n | |
| rr=[];cc=[];vv=[];rf=[];f=0 | |
| for axis in (0,1): | |
| for i in range(n-(axis==0)): | |
| for j in range(n-(axis==1)): | |
| a=i*n+j; b=(i+(axis==0))*n+j+(axis==1) | |
| rr.extend([a,b]);cc.extend([f,f]);vv.extend([1/h,-1/h]) | |
| rf.append(.5*(rho.ravel()[a]+rho.ravel()[b])); f+=1 | |
| D=sparse.coo_matrix((vv,(rr,cc)),shape=(n*n,f)).tocsr() | |
| K=(h*h*(D@sparse.diags(1/np.asarray(rf))@D.T)).toarray() | |
| mass=(h*h/bulk).ravel() | |
| A=K/np.sqrt(mass[:,None]*mass[None,:]) | |
| return X,Y,rho,bulk,mass,K,A | |
| def port(X,Y,bulk,centres,zero_mean): | |
| n=X.shape[0]; out=[] | |
| for x,y in centres: | |
| f=np.exp(-((X-x)**2+(Y-y)**2)/(2*CFG['source_receiver_sigma']**2)) | |
| f*=n*n/f.sum() | |
| if zero_mean:f-=f.mean() | |
| out.append((np.sqrt(bulk)*f/n).ravel()) | |
| return np.array(out).T | |
| def eig(A): | |
| lam,V=linalg.eigh((A+A.T)*.5,driver='evd',check_finite=False) | |
| if lam[0]<-1e-10*max(lam[-1],1):raise RuntimeError('negative stiffness') | |
| lam=np.maximum(lam,0); lam[lam<1e-10]=0 | |
| return lam,V | |
| def response(lam,V,B,R,t,freq,field=False): | |
| b=V.T@B; r=R.T@V | |
| ct=np.cos(t[:,None]*np.sqrt(lam)[None,:]) | |
| y=np.einsum('rm,tm,ms->trs',r,ct,b,optimize=True) | |
| u=np.einsum('im,tm,ms->tis',V,ct,b,optimize=True) if field else None | |
| s=CFG['laplace_eta']+2j*np.pi*freq | |
| f=s[:,None]/(s[:,None]**2+lam[None,:]) | |
| H=np.einsum('rm,fm,ms->frs',r,f,b,optimize=True) | |
| return y,u,H | |
| def relative(a,b):return float(np.linalg.norm(a-b)/max(np.linalg.norm(b),1e-30)) | |
| def component_basis(n,mass,K,max_modes): | |
| """One globally assembled interface: there is no duplicated interface mass. | |
| T=[I_G; -K_ii^-1 K_iG] plus fixed-interface generalized eigenmodes. | |
| Each interior block has homogeneous Dirichlet data at the shared interface. | |
| All outer boundaries retain the original Neumann conditions. | |
| """ | |
| mid=n//2-1 | |
| interface=np.arange(mid*n,(mid+1)*n) | |
| interiors=[np.arange(0,mid*n),np.arange((mid+1)*n,n*n)] | |
| T0=np.zeros((n*n,n)); T0[interface]=np.eye(n) | |
| pieces=[]; raw_eigs=[] | |
| for ii in interiors: | |
| kii=K[np.ix_(ii,ii)]; kib=K[np.ix_(ii,interface)] | |
| lift=-linalg.solve(kii,kib,assume_a='pos',check_finite=False) | |
| T0[ii]=lift | |
| mi=mass[ii] | |
| ai=kii/np.sqrt(mi[:,None]*mi[None,:]) | |
| vals,vec=linalg.eigh(ai,subset_by_index=[0,max_modes-1],driver='evr',check_finite=False) | |
| modes=np.zeros((n*n,max_modes));modes[ii]=vec/np.sqrt(mi[:,None]) | |
| pieces.append(modes);raw_eigs.append(vals) | |
| return T0,pieces,raw_eigs,interface,interiors | |
| def online_time(lam,V,B,R,t,freq): | |
| response(lam,V,B,R,t,freq) | |
| times=[] | |
| for _ in range(3): | |
| start=time.perf_counter();response(lam,V,B,R,t,freq);times.append(time.perf_counter()-start) | |
| return float(np.median(times)) | |
| def main(): | |
| start_all=time.perf_counter(); cfg=HERE/'frozen_config.json' | |
| if cfg.exists() and json.loads(cfg.read_text())!=CFG:raise RuntimeError('Configuration differs from existing results') | |
| dump(cfg,CFG);(HERE/'config.sha256').write_text(hashlib.sha256(cfg.read_bytes()).hexdigest()+' frozen_config.json\n') | |
| t=np.linspace(0,CFG['time_end'],CFG['samples']);freq=np.linspace(*CFG['frequency_cycles_per_time']) | |
| short=(t>0)&(t<=CFG['short_time_end']);long=t>0 | |
| rows=[];checks=[];raw={'time':t,'frequency':freq}; fields={}; setup_rows=[] | |
| for name in CFG['materials']: | |
| print('MATERIAL',name,flush=True);cache={} | |
| coarse=sorted(set(int(np.floor(np.sqrt(n+2*r)+.5)) for n in CFG['grids'] for r in CFG['internal_modes_per_patch'])) | |
| ns=sorted(set(CFG['grids']+coarse+[CFG['reference_grid']]+([CFG['audit_grid']] if name==CFG['audit_material'] else []))) | |
| for n in ns: | |
| t0=time.perf_counter();X,Y,rho,bulk,mass,K,A=build(n,name);assembly=time.perf_counter()-t0 | |
| t0=time.perf_counter();lam,V=eig(A);esec=time.perf_counter()-t0 | |
| B=port(X,Y,bulk,CFG['source_centres'],True);R=port(X,Y,bulk,CFG['receiver_centres'],False) | |
| y,u,H=response(lam,V,B,R,t,freq,field=n in CFG['grids']) | |
| on=online_time(lam,V,B,R,t,freq) | |
| cache[n]={'y':y,'H':H,'setup':assembly+esec,'online':on} | |
| raw[f'{name}_n{n}_full_y']=y;raw[f'{name}_n{n}_full_H']=H | |
| if n in CFG['grids']: | |
| fields[f'{name}_n{n}_full_snapshots']=u[[0,160,320,480,640]] | |
| raw[f'{name}_n{n}_rho']=rho;raw[f'{name}_n{n}_bulk']=bulk | |
| t0=time.perf_counter();T0,pieces,evals,interface,interiors=component_basis(n,mass,K,max(CFG['internal_modes_per_patch']));basis_build=time.perf_counter()-t0 | |
| constant_error=float(np.max(np.abs(T0@np.ones(n)-1))) | |
| interior_disconnect=float(np.max(np.abs(K[np.ix_(interiors[0],interiors[1])]),initial=0)) | |
| for r in CFG['internal_modes_per_patch']: | |
| t0=time.perf_counter() | |
| T=np.column_stack([T0]+[p[:,:r] for p in pieces]) | |
| W=np.sqrt(mass[:,None])*T | |
| Q,_=linalg.qr(W,mode='economic',check_finite=False) | |
| Ar=Q.T@A@Q;lr,Vr=eig(Ar);Br=Q.T@B;Rr=Q.T@R | |
| extra=time.perf_counter()-t0 | |
| yy,ur,HH=response(lr,Vr,Br,Rr,t,freq,field=True) | |
| uu=np.einsum('ir,trs->tis',Q,ur,optimize=True) | |
| ron=online_time(lr,Vr,Br,Rr,t,freq) | |
| phase=np.angle(HH*np.conj(H));wt=np.abs(H)**2 | |
| per_source=[relative(yy[long,:,s],y[long,:,s]) for s in range(B.shape[1])] | |
| row={'material':name,'grid':n,'method':'static_condensation' if r==0 else 'dynamic_condensation','modes_per_patch':r,'pressure_dof':Q.shape[1], | |
| 'same_grid_receiver_error':relative(yy[long],y[long]),'same_grid_short_receiver_error':relative(yy[short],y[short]), | |
| 'same_grid_field_error':relative(uu[long],u[long]),'same_grid_transfer_error':relative(HH,H), | |
| 'weighted_phase_error_rad':float(np.sum(wt*np.abs(phase))/wt.sum()), | |
| 'worst_source_receiver_error':max(per_source),'source1_receiver_error':per_source[0], 'source2_receiver_error':per_source[1], 'source3_receiver_error':per_source[2], | |
| 'initial_energy_retained':float(np.linalg.norm(Br)**2/np.linalg.norm(B)**2), | |
| 'setup_seconds_shared_max32_basis':assembly+basis_build+extra,'receiver_online_seconds':ron, | |
| 'full_setup_seconds':assembly+esec,'full_receiver_online_seconds':on, | |
| 'online_speedup':on/ron,'same_medium_1query_seconds_shared_setup':assembly+basis_build+extra+ron, | |
| 'same_medium_100query_seconds_shared_setup':(assembly+basis_build+extra)/100+ron, | |
| 'near_matched_coarse_grid':int(np.floor(np.sqrt(Q.shape[1])+.5))} | |
| rows.append(row) | |
| coeff=Vr.T@Br; om=np.sqrt(lr) | |
| energy=np.sum((np.cos(t[:,None,None]*om[None,:,None])*coeff[None,:,:])**2+(np.sin(t[:,None,None]*om[None,:,None])*coeff[None,:,:])**2,axis=1) | |
| _,_,Hcol=response(lr,Vr,Br,Br,t[:1],freq) | |
| minreal=min(linalg.eigvalsh((z+z.conj().T)/2)[0] for z in Hcol) | |
| Mr=T.T@(mass[:,None]*T);Kr=T.T@K@T | |
| sqrtA=(Vr*np.sqrt(lr))@Vr.T | |
| checks.append({'material':name,'grid':n,'modes_per_patch':r,'static_constant_error':constant_error,'interior_disconnect':interior_disconnect, | |
| 'mass_min_eigenvalue':float(linalg.eigvalsh(Mr)[0]),'stiffness_relative_symmetry':relative(Kr,Kr.T), | |
| 'orthonormality_defect':float(np.max(np.abs(Q.T@Q-np.eye(Q.shape[1])))), | |
| 'min_stiffness_eigenvalue':float(linalg.eigvalsh(Ar)[0]), | |
| 'passive_generator_skew_defect':float(np.max(np.abs(sqrtA-sqrtA.T))), | |
| 'energy_drift':float(np.max(np.abs(energy/energy[0]-1))), | |
| 'collocated_positive_real_min_eigenvalue':float(minreal)}) | |
| raw[f'{name}_n{n}_r{r}_y']=yy;raw[f'{name}_n{n}_r{r}_H']=HH | |
| fields[f'{name}_n{n}_r{r}_snapshots']=uu[[0,160,320,480,640]] | |
| print(' n',n,'r',r,'DOF',Q.shape[1],'receiver',round(row['same_grid_receiver_error'],5),'retained',round(row['initial_energy_retained'],5),flush=True) | |
| print(' full',n,'setup',round(assembly+esec,3),'online',round(on,4),flush=True) | |
| ref=cache[CFG['reference_grid']] | |
| for row in rows: | |
| if row['material']!=name:continue | |
| n=row['grid'];r=row['modes_per_patch'];c=row['near_matched_coarse_grid'] | |
| yy=raw[f'{name}_n{n}_r{r}_y'];HH=raw[f'{name}_n{n}_r{r}_H'] | |
| row.update(receiver_error_vs_48=relative(yy[long],ref['y'][long]),transfer_error_vs_48=relative(HH,ref['H']), | |
| full_grid_receiver_error_vs_48=relative(cache[n]['y'][long],ref['y'][long]), | |
| matched_coarse_pressure_dof=c*c,matched_coarse_receiver_error_vs_48=relative(cache[c]['y'][long],ref['y'][long]), | |
| matched_coarse_transfer_error_vs_48=relative(cache[c]['H'],ref['H']), | |
| matched_coarse_setup_seconds=cache[c]['setup'],matched_coarse_receiver_online_seconds=cache[c]['online']) | |
| for n in ns: | |
| setup_rows.append({'material':name,'grid':n,'pressure_dof':n*n,'setup_seconds':cache[n]['setup'],'receiver_online_seconds':cache[n]['online'], | |
| 'receiver_error_vs_48':relative(cache[n]['y'][long],ref['y'][long]),'transfer_error_vs_48':relative(cache[n]['H'],ref['H'])}) | |
| dump(HERE/'structural_checks.json',checks) | |
| for path,rr in [(HERE/'all_results.csv',rows),(HERE/'full_grid_results.csv',setup_rows)]: | |
| with path.open('w',newline='') as f:w=csv.DictWriter(f,fieldnames=list(rr[0]));w.writeheader();w.writerows(rr) | |
| np.savez_compressed(HERE/'receiver_and_transfer_responses.npz',**raw) | |
| np.savez_compressed(HERE/'field_snapshots.npz',**fields) | |
| summary=[] | |
| for n in CFG['grids']: | |
| for r in CFG['internal_modes_per_patch']: | |
| rr=[x for x in rows if x['grid']==n and x['modes_per_patch']==r] | |
| summary.append({'grid':n,'modes_per_patch':r,'pressure_dof':rr[0]['pressure_dof'],**{key:float(np.mean([x[key] for x in rr])) for key in ['same_grid_receiver_error','same_grid_field_error','same_grid_transfer_error','receiver_error_vs_48','matched_coarse_receiver_error_vs_48','initial_energy_retained','online_speedup','receiver_online_seconds','matched_coarse_receiver_online_seconds']}}) | |
| audit=[x for x in setup_rows if x['material']==CFG['audit_material'] and x['grid']==CFG['audit_grid']][0] | |
| result={'status':'development diagnostic','summary':summary,'reference_48_vs_64_selected_material':audit, | |
| 'structural_all_pass':all(x['mass_min_eigenvalue']>0 and x['static_constant_error']<1e-10 and x['interior_disconnect']==0 and x['energy_drift']<1e-12 and x['collocated_positive_real_min_eigenvalue']>-1e-10 for x in checks), | |
| 'elapsed_seconds':time.perf_counter()-start_all} | |
| dump(HERE/'summary.json',result) | |
| if __name__=='__main__':main() | |