def test_default(self): z, p, k = synthesizeNTF() e_k = 1 e_z = np.ones(3) e_p = [0.7654 - 0.2793j, 0.7654 + 0.2793j, 0.6694] e_p = cplxpair(e_p) np.testing.assert_almost_equal(k, e_k, 6) np.testing.assert_almost_equal(z, e_z, 6) np.testing.assert_almost_equal(p, e_p, 4)
def test_opt3(self): z, p, k = synthesizeNTF(opt=3) e_k = 1 e_z = [1.0000, 0.9993 - 0.0382j, 0.9993 + 0.0382j] e_z = cplxpair(e_z) e_p = [0.6692, 0.7652 - 0.2795j, 0.7652 + 0.2795j] e_p = cplxpair(e_p) np.testing.assert_almost_equal(k, e_k, 6) np.testing.assert_almost_equal(z, e_z, 4) np.testing.assert_almost_equal(p, e_p, 4)
def test_BP6(self): z, p, k = synthesizeNTF(order=6, f0=0.3) e_k = 1 e_z = np.concatenate(((-0.3090 + 0.9511j) * np.ones(3), (-0.3090 - 0.9511j) * np.ones(3))) e_z = cplxpair(e_z) e_p = [ -0.4238 - 0.7906j, -0.4238 + 0.7906j, -0.2480 - 0.7802j, -0.2480 + 0.7802j, -0.1290 - 0.8985j, -0.1290 + 0.8985j ] e_p = cplxpair(e_p) np.testing.assert_almost_equal(k, e_k, 6) np.testing.assert_almost_equal(z, e_z, 4) np.testing.assert_almost_equal(p, e_p, 4)
A1 = 0.2 # Amplitude of first signal A2 = 0.44 # Amplitude of the second signal f1 = 1003 # Frequency used to test the first test signal with a tone f2 = 3193 # Frequency used to test the second test signal with a tone Amax = 0.64 # Max amplitude used for testing # Clock frequency of modulator fphi = 2*OSR*(B1) # Cut off frequency of reconstruction filter # ...set twice as wide as it should to better see artifacts brk = B1/fphi # Create NTF with DELSIG synthesizeNTF ntf_a = synthesizeNTF(order=4, osr=OSR, opt=3, H_inf=1.5) # Prepare frequency grid ff_log = np.logspace(np.log10(0.5E-5), np.log10(0.5), 4096) ff_lin = np.linspace(0, 0.5, 1024) # Compute magnitude responses of NTF for plotting ntf_a_mag = lambda f: np.abs(evalTF(ntf_a, np.exp(-2j*np.pi*f))) vv_ntf_a_log = ntf_a_mag(ff_log) vv_ntf_a_lin = ntf_a_mag(ff_lin) # Design output filter hz = signal.butter(4, 2*brk, btype='low') # Compute magnitude responses of output filter for plotting hz_mag = lambda f: np.abs(evalTF(hz, np.exp(-2j*np.pi*f)))
plt.ylim(0, 1.1) plt.xscale('log', basex=10) plt.gca().set_xticks([1E-5, 1. / 2]) plt.gca().set_xticklabels(['$10^{-5}$', r'$\frac{1}{2}$']) plt.xlabel('$f$', x=1.) plt.ylabel('$w(f)$', y=0.9) plt.grid(True, 'both') plt.suptitle('Weighting function') plt.tight_layout(rect=[0, 0, 1, 0.98]) print("... computing optimal NTF") ntf_opti = ntf_fir_weighting(order, w1, H_inf=H_inf) ntf_opti_mag = lambda f: np.abs(evalTF(ntf_opti, np.exp(-2j * np.pi * f))) print("... computing delsig NTF") ntf_delsig = synthesizeNTF(delsig_order, OSR, 3, H_inf, 0) ntf_delsig_mag = lambda f: np.abs(evalTF(ntf_delsig, np.exp(-2j * np.pi * f))) print("... plotting optimal NTF amplitude response") vv_mag = dbv(ntf_opti_mag(ff)) vv_mag_delsig = dbv(ntf_delsig_mag(ff)) plt.figure() plt.plot(ff, vv_mag, label='Proposed') plt.plot(ff, vv_mag_delsig, 'r-o', linewidth=0.5, markevery=24, markersize=3, label='Reference') plt.xlim(1e-5, 1. / 2)
A1 = 0.2 # Amplitude of first signal A2 = 0.44 # Amplitude of the second signal f1 = 1003 # Frequency used to test the first test signal with a tone f2 = 3193 # Frequency used to test the second test signal with a tone Amax = 0.64 # Max amplitude used for testing # Clock frequency of modulator fphi = 2 * OSR * (B1) # Cut off frequency of reconstruction filter # ...set twice as wide as it should to better see artifacts brk = B1 / fphi # Create NTF with DELSIG synthesizeNTF ntf_a = synthesizeNTF(order=4, osr=OSR, opt=3, H_inf=1.5) # Prepare frequency grid ff_log = np.logspace(np.log10(0.5E-5), np.log10(0.5), 4096) ff_lin = np.linspace(0, 0.5, 1024) # Compute magnitude responses of NTF for plotting ntf_a_mag = lambda f: np.abs(evalTF(ntf_a, np.exp(-2j * np.pi * f))) vv_ntf_a_log = ntf_a_mag(ff_log) vv_ntf_a_lin = ntf_a_mag(ff_lin) # Design output filter hz = signal.butter(4, 2 * brk, btype='low') # Compute magnitude responses of output filter for plotting hz_mag = lambda f: np.abs(evalTF(hz, np.exp(-2j * np.pi * f)))
plt.ylim(0, 1.1) plt.xscale('log', basex=10) plt.gca().set_xticks([1E-5, 1./2]) plt.gca().set_xticklabels(['$10^{-5}$', r'$\frac{1}{2}$']) plt.xlabel('$f$', x=1.) plt.ylabel('$w(f)$', y=0.9) plt.grid(True, 'both') plt.suptitle('Weighting function') plt.tight_layout(rect=[0, 0, 1, 0.98]) print("... computing optimal NTF") ntf_opti = ntf_fir_weighting(order, w1, H_inf=H_inf) ntf_opti_mag = lambda f: np.abs(evalTF(ntf_opti, np.exp(-2j*np.pi*f))) print("... computing delsig NTF") ntf_delsig = synthesizeNTF(delsig_order, OSR, 3, H_inf, 0) ntf_delsig_mag = lambda f: np.abs(evalTF(ntf_delsig, np.exp(-2j*np.pi*f))) print("... plotting optimal NTF amplitude response") vv_mag = dbv(ntf_opti_mag(ff)) vv_mag_delsig = dbv(ntf_delsig_mag(ff)) plt.figure() plt.plot(ff, vv_mag, label='Proposed') plt.plot(ff, vv_mag_delsig, 'r-o', linewidth=0.5, markevery=24, markersize=3, label='Reference') plt.xlim(1e-5, 1./2) # plt.ylim(0,1.1) plt.xscale('log', basex=10) plt.gca().set_xticks([1E-5, 1./2]) plt.gca().set_xticklabels(['$10^{-5}$', r'$\frac{1}{2}$']) plt.xlabel('$f$', x=1.)
# Set the OSRs and the h_inf (gamma) values used for the plots # OSR values are arranged so that each one is twice the previous one # hinf values are arranged so that each value is the square root of the # previous one. Also set the orders used for testing. osrs = np.asarray([16, 32, 64, 128, 256]) hinfs = np.asarray([2.25**(1 / (2.**i)) for i in range(5)]) orders = np.asarray([1, 2, 3, 4, 5]) # Prepare a vector to store the noise gain for obtained at the many # test conditions g0s = np.zeros((orders.size, osrs.size)) # Synthesize the NTF for all the orders and OSR values at h_inf=1.5 for i, osr in enumerate(osrs): for j, order in enumerate(orders): ntf1 = synthesizeNTF(order, osr=osr, opt=3, H_inf=1.5) f1, f2 = ds_f1f2(osr) g0 = quantization_weighted_noise_gain(ntf1, None, (f1, f2)) # print order, osr, f1, f2, g0, dbp(g0) g0s[j, i] = g0 # Make the plot: quantization noise gain versus OSR for the different # orders plt.figure() plt.xscale('log') markers = 'ov^<>' for i, order in enumerate(orders): plt.plot(osrs, dbp(g0s[i]), "-" + markers[i], label='%d' % order) plt.legend(loc='upper right', fontsize=9) plt.xlabel("OSR") plt.ylabel("$P_N$ [dB]") # Print some interesting data from the designs
# Care: in butter the cut of frequency is specified as a number from 0 to 1 # where 1 is fphi/2, not fphi hz = sp.signal.butter(1, 2 * (2 * B) / fphi, btype='low') # Compute impulse response print("...computing impulse response of filter") hz_ir = impulse_response(hz, db=60) # Compute the optimal NTF print("... computing optimal NTF") q0 = q0_from_filter_ir(order, hz_ir) ntf_opti = ntf_fir_from_q0(q0, H_inf=H_inf) # Compute an NTF with DELSIG, for comparison print("... computing delsig NTF") ntf_delsig = synthesizeNTF(4, OSR, 3, H_inf, 0) # Determine freq values for which plots are created fmin = 10**np.ceil(np.log10(2 * B / OSR)) fmax = 10**np.floor(np.log10(fphi / 2)) ff = np.logspace(np.log10(fmin), np.log10(fmax), 1000) # Compute frequency response data resp_filt = np.abs(evalTF(hz, np.exp(1j * 2 * np.pi * ff / fphi))) resp_opti = np.abs(evalTF(ntf_opti, np.exp(1j * 2 * np.pi * ff / fphi))) resp_delsig = np.abs(evalTF(ntf_delsig, np.exp(1j * 2 * np.pi * ff / fphi))) # Plot frequency response plt.figure() plt.semilogx(ff, dbv(resp_filt), 'b', label="Output filter") plt.semilogx(ff, dbv(resp_opti), 'r', label="Optimal NTF")
def test_default(self): ntf = synthesizeNTF() plotPZ(ntf)
def test_default(self): ntf = synthesizeNTF() plotPZ(ntf)
# Set the OSRs and the h_inf (gamma) values used for the plots # OSR values are arranged so that each one is twice the previous one # hinf values are arranged so that each value is the square root of the # previous one. Also set the orders used for testing. osrs = np.asarray([16, 32, 64, 128, 256]) hinfs = np.asarray([2.25**(1/(2.**i)) for i in range(5)]) orders = np.asarray([1, 2, 3, 4, 5]) # Prepare a vector to store the noise gain for obtained at the many # test conditions g0s = np.zeros((orders.size, osrs.size)) # Synthesize the NTF for all the orders and OSR values at h_inf=1.5 for i, osr in enumerate(osrs): for j, order in enumerate(orders): ntf1 = synthesizeNTF(order, osr=osr, opt=3, H_inf=1.5) f1, f2 = ds_f1f2(osr) g0 = quantization_weighted_noise_gain(ntf1, None, (f1, f2)) # print order, osr, f1, f2, g0, dbp(g0) g0s[j, i] = g0 # Make the plot: quantization noise gain versus OSR for the different # orders plt.figure() plt.xscale('log') markers = 'ov^<>' for i, order in enumerate(orders): plt.plot(osrs, dbp(g0s[i]), "-"+markers[i], label='%d' % order) plt.legend(loc='upper right', fontsize=9) plt.xlabel("OSR") plt.ylabel("$P_N$ [dB]") # Print some interesting data from the designs
A2 = 0.44 # Amplitude of the second signal f1 = 1003 # Frequency used to test the first test signal with a tone f2 = 3193 # Frequency used to test the second test signal with a tone Amax = 0.34 # Max amplitude used for testing # Clock frequency of modulator fphi = 2*OSR*(B1+B2) # Cut off frequency of reconstruction filters # ...set twice as wide as they should to better see artifacts brk1 = B1/fphi brk2 = 0.5-B2/fphi # Create NTF with DELSIG synthesizeNTF ntf_a = synthesizeNTF(order=4, osr=2*OSR, opt=3, H_inf=np.sqrt(1.5)) ntf_dual_a = mirroredNTF(ntf_a) # Prepare frequency grid ff_log = np.logspace(np.log10(0.5E-5), np.log10(0.5), 4096) ff_lin = np.linspace(0, 0.5, 1024) # Compute magnitude responses of NTF for plotting ntf_a_mag = lambda f: np.abs(evalTF(ntf_a, np.exp(-2j*np.pi*f))) vv_ntf_a_log = ntf_a_mag(ff_log) vv_ntf_a_lin = ntf_a_mag(ff_lin) ntf_dual_a_mag = lambda f: np.abs(evalTF(ntf_dual_a, np.exp(-2j*np.pi*f))) vv_ntf_dual_a_log = ntf_dual_a_mag(ff_log) vv_ntf_dual_a_lin = ntf_dual_a_mag(ff_lin) # Design output filter
plt.legend() plt.ion() plt.show() plt.ioff() # Compute optimal and benchmark NTFs hz0043_ir = impulse_response(hz0043) hz02_ir = impulse_response(hz02) hz06_ir = impulse_response(hz06) q0_0043 = q0_from_filter_ir(P, hz0043_ir) ntf0043 = ntf_fir_from_q0(q0_0043) q0_02 = q0_from_filter_ir(P, hz02_ir) ntf02 = ntf_fir_from_q0(q0_02) q0_06 = q0_from_filter_ir(P, hz06_ir) ntf06 = ntf_fir_from_q0(q0_06) delsig_ntf = synthesizeNTF(DELSIG_P, OSR, 3, 1.5, 0) # Plot the NTFs nyz0043 = evalTF(ntf0043, np.exp(2j * np.pi * ff / fphi)) nyz02 = evalTF(ntf02, np.exp(2j * np.pi * ff / fphi)) nyz06 = evalTF(ntf06, np.exp(2j * np.pi * ff / fphi)) delsig_ny = evalTF(delsig_ntf, np.exp(2j * np.pi * ff / fphi)) plt.figure() plt.semilogx(ff, dbv(np.abs(nyz0043)), 'b', label='opt @ $\sigma=0.043$') plt.semilogx(ff, dbv(np.abs(nyz02)), 'r', label='opt @ $\sigma=0.2$') plt.semilogx(ff, dbv(np.abs(nyz06)), 'g', label='opt @ $\sigma=0.6$') plt.semilogx(ff, dbv(np.abs(delsig_ny)), 'y', label='benchmark') plt.xlabel('$f$ [Hz]') plt.ylabel('[dB]') plt.suptitle("NTF magnitude response")
# Care: in butter the cut of frequency is specified as a number from 0 to 1 # where 1 is fphi/2, not fphi hz = sp.signal.butter(1, 2*(2*B)/fphi, btype='low') # Compute impulse response print("...computing impulse response of filter") hz_ir = impulse_response(hz, db=60) # Compute the optimal NTF print("... computing optimal NTF") q0 = q0_from_filter_ir(order, hz_ir) ntf_opti = ntf_fir_from_q0(q0, H_inf=H_inf) # Compute an NTF with DELSIG, for comparison print("... computing delsig NTF") ntf_delsig = synthesizeNTF(4, OSR, 3, H_inf, 0) # Determine freq values for which plots are created fmin = 10**np.ceil(np.log10(2*B/OSR)) fmax = 10**np.floor(np.log10(fphi/2)) ff = np.logspace(np.log10(fmin), np.log10(fmax), 1000) # Compute frequency response data resp_filt = np.abs(evalTF(hz, np.exp(1j*2*np.pi*ff/fphi))) resp_opti = np.abs(evalTF(ntf_opti, np.exp(1j*2*np.pi*ff/fphi))) resp_delsig = np.abs(evalTF(ntf_delsig, np.exp(1j*2*np.pi*ff/fphi))) # Plot frequency response plt.figure() plt.semilogx(ff, dbv(resp_filt), 'b', label="Output filter") plt.semilogx(ff, dbv(resp_opti), 'r', label="Optimal NTF")
A2 = 0.44 # Amplitude of the second signal f1 = 1003 # Frequency used to test the first test signal with a tone f2 = 3193 # Frequency used to test the second test signal with a tone Amax = 0.34 # Max amplitude used for testing # Clock frequency of modulator fphi = 2 * OSR * (B1 + B2) # Cut off frequency of reconstruction filters # ...set twice as wide as they should to better see artifacts brk1 = B1 / fphi brk2 = 0.5 - B2 / fphi # Create NTF with DELSIG synthesizeNTF ntf_a = synthesizeNTF(order=4, osr=2 * OSR, opt=3, H_inf=np.sqrt(1.5)) ntf_dual_a = mirroredNTF(ntf_a) # Prepare frequency grid ff_log = np.logspace(np.log10(0.5E-5), np.log10(0.5), 4096) ff_lin = np.linspace(0, 0.5, 1024) # Compute magnitude responses of NTF for plotting ntf_a_mag = lambda f: np.abs(evalTF(ntf_a, np.exp(-2j * np.pi * f))) vv_ntf_a_log = ntf_a_mag(ff_log) vv_ntf_a_lin = ntf_a_mag(ff_lin) ntf_dual_a_mag = lambda f: np.abs(evalTF(ntf_dual_a, np.exp(-2j * np.pi * f))) vv_ntf_dual_a_log = ntf_dual_a_mag(ff_log) vv_ntf_dual_a_lin = ntf_dual_a_mag(ff_lin) # Design output filter
plt.legend() plt.ion() plt.show() plt.ioff() # Compute optimal and benchmark NTFs hz0043_ir = impulse_response(hz0043) hz02_ir = impulse_response(hz02) hz06_ir = impulse_response(hz06) q0_0043 = q0_from_filter_ir(P, hz0043_ir) ntf0043 = ntf_fir_from_q0(q0_0043) q0_02 = q0_from_filter_ir(P, hz02_ir) ntf02 = ntf_fir_from_q0(q0_02) q0_06 = q0_from_filter_ir(P, hz06_ir) ntf06 = ntf_fir_from_q0(q0_06) delsig_ntf = synthesizeNTF(DELSIG_P, OSR, 3, 1.5, 0) # Plot the NTFs nyz0043 = evalTF(ntf0043, np.exp(2j*np.pi*ff/fphi)) nyz02 = evalTF(ntf02, np.exp(2j*np.pi*ff/fphi)) nyz06 = evalTF(ntf06, np.exp(2j*np.pi*ff/fphi)) delsig_ny = evalTF(delsig_ntf, np.exp(2j*np.pi*ff/fphi)) plt.figure() plt.semilogx(ff, dbv(np.abs(nyz0043)), 'b', label='opt @ $\sigma=0.043$') plt.semilogx(ff, dbv(np.abs(nyz02)), 'r', label='opt @ $\sigma=0.2$') plt.semilogx(ff, dbv(np.abs(nyz06)), 'g', label='opt @ $\sigma=0.6$') plt.semilogx(ff, dbv(np.abs(delsig_ny)), 'y', label='benchmark')