ADComp / studies /patch_2d /run_patch.py
Bobchen1980's picture
Upload folder using huggingface_hub (part 3)
cfbe945 verified
Raw History Blame Contribute Delete
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()