def test_svd_mass_res(file_prefix='F_m'): """ test SVD decomposition of mass residuals by generating SVD, saving to file and reloading """ from proteus.deim_utils import read_snapshots,generate_svd_decomposition ns = get_burgers_ns("test_svd_mass_res",T=0.1,nDTout=10,archive_pod_res=True) failed = ns.calculateSolution("run_svd_mass_res") assert not failed from proteus import Archiver archive = Archiver.XdmfArchive(".","test_svd_mass_res",readOnly=True) U,s,V=generate_svd_decomposition(archive,len(ns.tnList),'mass_residual0',file_prefix) S_svd = np.dot(U,np.dot(np.diag(s),V)) #now load back in and test S = read_snapshots(archive,len(ns.tnList),'mass_residual0') npt.assert_almost_equal(S,S_svd)
def test_svd_soln(): """ test SVD decomposition of solution by generating SVD, saving to file and reloading """ from proteus.deim_utils import read_snapshots, generate_svd_decomposition ns = get_burgers_ns("test_svd_soln", T=0.1, nDTout=10, archive_pod_res=True) failed = ns.calculateSolution("run_svd_soln") assert not failed from proteus import Archiver archive = Archiver.XdmfArchive(".", "test_svd_soln", readOnly=True) U, s, V = generate_svd_decomposition(archive, len(ns.tnList), 'u', 'soln') S_svd = np.dot(U, np.dot(np.diag(s), V)) #now load back in and test S = read_snapshots(archive, len(ns.tnList), 'u') npt.assert_almost_equal(S, S_svd)
def deim_approx(T=0.1,nDTout=10,m=5,m_mass=5): """ Follow basic setup for DEIM approximation - generate a burgers solution, saving spatial and 'mass' residuals - generate SVDs for snapshots - for both residuals F_s and F_m - pick $m$, dimension for snapshot reduced basis $\mathbf{U}_m$ - call DEIM algorithm to determine $\vec \rho$ and compute projection matrix $\mathbf{P}_F=\mathbf{U}_m(\mathbf{P}^T\mathbf{U}_m)^{-1}$ For selected timesteps - extract fine grid solution from archive, $\vec y$ - for both residuals F=F_s and F_m - evaluate $\vec F(\vec y)$ at indices in $\vec \rho \rightarrow \vec c$ - apply DEIM interpolant $\tilde{\vec F} = \mathbf{P}_F\vec c$ - compute error $\|F-\tilde{\vec F}\| - visualize """ from proteus.deim_utils import read_snapshots,generate_svd_decomposition ##run fine grid problem ns = get_burgers_ns("test_deim_approx",T=T,nDTout=nDTout,archive_pod_res=True) failed = ns.calculateSolution("run_deim_approx") assert not failed from proteus import Archiver archive = Archiver.XdmfArchive(".","test_deim_approx",readOnly=True) ##perform SVD on spatial residual U,s,V=generate_svd_decomposition(archive,len(ns.tnList),'spatial_residual0','F_s') U_m,s_m,V_m=generate_svd_decomposition(archive,len(ns.tnList),'mass_residual0','F_m') from proteus.deim_utils import deim_alg ##calculate DEIM indices and projection matrix rho,PF = deim_alg(U,m) #also 'mass' term rho_m,PF_m = deim_alg(U_m,m_mass) ##for comparison, grab snapshots of solution and residual Su = read_snapshots(archive,len(ns.tnList),'u') Sf = read_snapshots(archive,len(ns.tnList),'spatial_residual0') Sm = read_snapshots(archive,len(ns.tnList),'mass_residual0') steps_to_test = np.arange(len(ns.tnList)) errors = np.zeros(len(steps_to_test),'d'); errors_mass = errors.copy() F_deim = np.zeros((Sf.shape[0],len(steps_to_test)),'d') Fm_deim = np.zeros((Sf.shape[0],len(steps_to_test)),'d') for i,istep in enumerate(steps_to_test): #solution on the fine grid u = Su[:,istep] #spatial residual evaluated from fine grid F = Sf[:,istep] #deim approximation on the fine grid F_deim[:,istep] = np.dot(PF,F[rho]) errors[i] = np.linalg.norm(F-F_deim[:,istep]) #repeat for 'mass residual' Fm= Sm[:,istep] #deim approximation on the fine grid Fm_deim[:,istep] = np.dot(PF_m,Fm[rho]) errors_mass[i] = np.linalg.norm(Fm-Fm_deim[:,istep]) # np.savetxt("deim_approx_errors_space_test_T={0}_nDT={1}_m={2}.dat".format(T,nDTout,m),errors) np.savetxt("deim_approx_errors_mass_test_T={0}_nDT={1}_m={2}.dat".format(T,nDTout,m_mass),errors_mass) return errors,errors_mass,F_deim,Fm_deim
def deim_approx(T=0.1, nDTout=10, m=5, m_mass=5): """ Follow basic setup for DEIM approximation - generate a burgers solution, saving spatial and 'mass' residuals - generate SVDs for snapshots - for both residuals F_s and F_m - pick $m$, dimension for snapshot reduced basis $\mathbf{U}_m$ - call DEIM algorithm to determine $\vec \rho$ and compute projection matrix $\mathbf{P}_F=\mathbf{U}_m(\mathbf{P}^T\mathbf{U}_m)^{-1}$ For selected timesteps - extract fine grid solution from archive, $\vec y$ - for both residuals F=F_s and F_m - evaluate $\vec F(\vec y)$ at indices in $\vec \rho \rightarrow \vec c$ - apply DEIM interpolant $\tilde{\vec F} = \mathbf{P}_F\vec c$ - compute error $\|F-\tilde{\vec F}\| - visualize """ from proteus.deim_utils import read_snapshots, generate_svd_decomposition ##run fine grid problem ns = get_burgers_ns("test_deim_approx", T=T, nDTout=nDTout, archive_pod_res=True) failed = ns.calculateSolution("run_deim_approx") assert not failed from proteus import Archiver archive = Archiver.XdmfArchive(".", "test_deim_approx", readOnly=True) ##perform SVD on spatial residual U, s, V = generate_svd_decomposition(archive, len(ns.tnList), 'spatial_residual0', 'F_s') U_m, s_m, V_m = generate_svd_decomposition(archive, len(ns.tnList), 'mass_residual0', 'F_m') from proteus.deim_utils import deim_alg ##calculate DEIM indices and projection matrix rho, PF = deim_alg(U, m) #also 'mass' term rho_m, PF_m = deim_alg(U_m, m_mass) ##for comparison, grab snapshots of solution and residual Su = read_snapshots(archive, len(ns.tnList), 'u') Sf = read_snapshots(archive, len(ns.tnList), 'spatial_residual0') Sm = read_snapshots(archive, len(ns.tnList), 'mass_residual0') steps_to_test = np.arange(len(ns.tnList)) errors = np.zeros(len(steps_to_test), 'd') errors_mass = errors.copy() F_deim = np.zeros((Sf.shape[0], len(steps_to_test)), 'd') Fm_deim = np.zeros((Sf.shape[0], len(steps_to_test)), 'd') for i, istep in enumerate(steps_to_test): #solution on the fine grid u = Su[:, istep] #spatial residual evaluated from fine grid F = Sf[:, istep] #deim approximation on the fine grid F_deim[:, istep] = np.dot(PF, F[rho]) errors[i] = np.linalg.norm(F - F_deim[:, istep]) #repeat for 'mass residual' Fm = Sm[:, istep] #deim approximation on the fine grid Fm_deim[:, istep] = np.dot(PF_m, Fm[rho]) errors_mass[i] = np.linalg.norm(Fm - Fm_deim[:, istep]) # np.savetxt( "deim_approx_errors_space_test_T={0}_nDT={1}_m={2}.dat".format( T, nDTout, m), errors) np.savetxt( "deim_approx_errors_mass_test_T={0}_nDT={1}_m={2}.dat".format( T, nDTout, m_mass), errors_mass) return errors, errors_mass, F_deim, Fm_deim