File size: 13,602 Bytes
cfbe945 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 | #!/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()
|